ccxt 4.3.21__py2.py3-none-any.whl → 4.3.23__py2.py3-none-any.whl

ccxt/coinex.py

@@ -10,6 +10,7 @@ from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
+from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
@@ -480,10 +481,53 @@ class coinex(Exchange, ImplicitAPI):
                     '36': RequestTimeout,  # Service timeout
                     '213': RateLimitExceeded,  # Too many requests
                     '107': InsufficientFunds,
+                    '158': PermissionDenied,  # {"code":158,"data":{},"message":"API permission is not allowed"}
                     '600': OrderNotFound,
                     '601': InvalidOrder,
                     '602': InvalidOrder,
                     '606': InvalidOrder,
+                    '3008': RequestTimeout,  # Service busy, please try again later.
+                    '3109': InsufficientFunds,  # {"code":3109,"data":{},"message":"balance not enough"}
+                    '3127': InvalidOrder,  # The order quantity is below the minimum requirement. Please adjust the order quantity.
+                    '3606': InvalidOrder,  # The price difference between the order price and the latest price is too large. Please adjust the order amount accordingly.
+                    '3610': ExchangeError,  # Order cancellation prohibited during the Call Auction period.
+                    '3612': InvalidOrder,  # The est. ask price is lower than the current bottom ask price. Please reduce the amount.
+                    '3613': InvalidOrder,  # The est. bid price is higher than the current top bid price. Please reduce the amount.
+                    '3614': InvalidOrder,  # The deviation between your est. filled price and the index price. Please reduce the amount.
+                    '3615': InvalidOrder,  # The deviation between your order price and the index price is too high. Please adjust your order price and try again.
+                    '3616': InvalidOrder,  # The order price exceeds the current top bid price. Please adjust the order price and try again.
+                    '3617': InvalidOrder,  # The order price exceeds the current bottom ask price. Please adjust the order price and try again.
+                    '3618': InvalidOrder,  # The deviation between your order price and the index price is too high. Please adjust your order price and try again.
+                    '3619': InvalidOrder,  # The deviation between your order price and the trigger price is too high. Please adjust your order price and try again.
+                    '3620': InvalidOrder,  # Market order submission is temporarily unavailable due to insufficient depth in the current market
+                    '3621': InvalidOrder,  # This order can't be completely executed and has been canceled.
+                    '3622': InvalidOrder,  # This order can't be set Only and has been canceled.
+                    '3627': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3628': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3629': InvalidOrder,  # The current market depth is low, please reduce your order amount and try again.
+                    '3632': InvalidOrder,  # The order price exceeds the current top bid price. Please adjust the order price and try again.
+                    '3633': InvalidOrder,  # The order price exceeds the current bottom ask price. Please adjust the order price and try again.
+                    '3634': InvalidOrder,  # The deviation between your est. filled price and the index price is too high. Please reduce the amount and try again.
+                    '3635': InvalidOrder,  # The deviation between your est. filled price and the index price is too high. Please reduce the amount and try again.
+                    '4001': ExchangeNotAvailable,  # Service unavailable, please try again later.
+                    '4002': RequestTimeout,  # Service request timed out, please try again later.
+                    '4003': ExchangeError,  # Internal error, please contact customer service for help.
+                    '4004': BadRequest,  # Parameter error, please check whether the request parameters are abnormal.
+                    '4005': AuthenticationError,  # Abnormal access_id, please check whether the value passed by X-COINEX-KEY is normal.
+                    '4006': AuthenticationError,  # Signature verification failed, please check the signature according to the documentation instructions.
+                    '4007': PermissionDenied,  # IP address prohibited, please check whether the whitelist or export IP is normal.
+                    '4008': AuthenticationError,  # Abnormal X-COIN-SIGN value, please check.
+                    '4009': ExchangeError,  # Abnormal request method, please check.
+                    '4010': ExchangeError,  # Expired request, please try again later.
+                    '4011': PermissionDenied,  # User prohibited from accessing, please contact customer service for help.
+                    '4017': ExchangeError,  # Signature expired, please try again later.
+                    '4115': AccountSuspended,  # User prohibited from trading, please contact customer service for help.
+                    '4117': BadSymbol,  # Trading hasattr(self, prohibited) market, please try again later.
+                    '4123': RateLimitExceeded,  # Rate limit triggered. Please adjust your strategy and reduce the request rate.
+                    '4130': ExchangeError,  # Futures trading prohibited, please try again later.
+                    '4158': ExchangeError,  # Trading prohibited, please try again later.
+                    '4213': RateLimitExceeded,  # The request is too frequent, please try again later.
+                    '4512': PermissionDenied,  # Insufficient sub-account permissions, please check.
                 },
                 'broad': {
                     'ip not allow visit': PermissionDenied,
@@ -4138,8 +4182,8 @@ class coinex(Exchange, ImplicitAPI):
 
     def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        fetch the history of funding payments paid and received on self account
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http034_funding_position
+        fetch the history of funding fee payments paid and received on self account
+        :see: https://docs.coinex.com/api/v2/futures/position/http/list-position-funding-history
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch funding history for
         :param int [limit]: the maximum number of funding history structures to retrieve
@@ -4148,53 +4192,45 @@ class coinex(Exchange, ImplicitAPI):
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' fetchFundingHistory() requires a symbol argument')
-        limit = 100 if (limit is None) else limit
         self.load_markets()
         market = self.market(symbol)
         request = {
             'market': market['id'],
-            'limit': limit,
-            # 'offset': 0,
-            # 'end_time': 1638990636000,
-            # 'windowtime': 1638990636000,
+            'market_type': 'FUTURES',
         }
+        request, params = self.handle_until_option('end_time', request, params)
         if since is not None:
             request['start_time'] = since
-        response = self.v1PerpetualPrivateGetPositionFunding(self.extend(request, params))
+        if limit is not None:
+            request['limit'] = limit
+        response = self.v2PrivateGetFuturesPositionFundingHistory(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "limit": 100,
-        #             "offset": 0,
-        #             "records": [
-        #                 {
-        #                     "amount": "0.0012",
-        #                     "asset": "USDT",
-        #                     "funding": "-0.0095688273996",
-        #                     "funding_rate": "0.00020034",
-        #                     "market": "BTCUSDT",
-        #                     "position_id": 62052321,
-        #                     "price": "39802.45",
-        #                     "real_funding_rate": "0.00020034",
-        #                     "side": 2,
-        #                     "time": 1650729623.933885,
-        #                     "type": 1,
-        #                     "user_id": 3620173,
-        #                     "value": "47.76294"
-        #                 },
-        #             ]
-        #         },
-        #         "message": "OK"
+        #         "data": [
+        #             {
+        #                 "ccy": "USDT",
+        #                 "created_at": 1715673620183,
+        #                 "funding_rate": "0",
+        #                 "funding_value": "0",
+        #                 "market": "BTCUSDT",
+        #                 "market_type": "FUTURES",
+        #                 "position_id": 306458800,
+        #                 "side": "long"
+        #             },
+        #         ],
+        #         "message": "OK",
+        #         "pagination": {
+        #             "has_next": True
+        #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        resultList = self.safe_value(data, 'records', [])
+        data = self.safe_list(response, 'data', [])
         result = []
-        for i in range(0, len(resultList)):
-            entry = resultList[i]
-            timestamp = self.safe_timestamp(entry, 'time')
-            currencyId = self.safe_string(entry, 'asset')
+        for i in range(0, len(data)):
+            entry = data[i]
+            timestamp = self.safe_integer(entry, 'created_at')
+            currencyId = self.safe_string(entry, 'ccy')
             code = self.safe_currency_code(currencyId)
             result.append({
                 'info': entry,
@@ -4203,14 +4239,14 @@ class coinex(Exchange, ImplicitAPI):
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
                 'id': self.safe_number(entry, 'position_id'),
-                'amount': self.safe_number(entry, 'funding'),
+                'amount': self.safe_number(entry, 'funding_value'),
             })
         return result
 
     def fetch_funding_rate(self, symbol: str, params={}):
         """
         fetch the current funding rate
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http008_market_ticker
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate
         :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `funding rate structure <https://docs.ccxt.com/#/?id=funding-rate-structure>`
@@ -4222,93 +4258,63 @@ class coinex(Exchange, ImplicitAPI):
         request = {
             'market': market['id'],
         }
-        response = self.v1PerpetualPublicGetMarketTicker(self.extend(request, params))
+        response = self.v2PublicGetFuturesFundingRate(self.extend(request, params))
         #
         #     {
-        #          "code": 0,
-        #         "data":
-        #         {
-        #             "date": 1650678472474,
-        #             "ticker": {
-        #                 "vol": "6090.9430",
-        #                 "low": "39180.30",
-        #                 "open": "40474.97",
-        #                 "high": "40798.01",
-        #                 "last": "39659.30",
-        #                 "buy": "39663.79",
-        #                 "period": 86400,
-        #                 "funding_time": 372,
-        #                 "position_amount": "270.1956",
-        #                 "funding_rate_last": "0.00022913",
-        #                 "funding_rate_next": "0.00013158",
-        #                 "funding_rate_predict": "0.00016552",
-        #                 "insurance": "16045554.83969682659674035672",
-        #                 "sign_price": "39652.48",
-        #                 "index_price": "39648.44250000",
-        #                 "sell_total": "22.3913",
-        #                 "buy_total": "19.4498",
-        #                 "buy_amount": "12.8942",
-        #                 "sell": "39663.80",
-        #                 "sell_amount": "0.9388"
+        #         "code": 0,
+        #         "data": [
+        #             {
+        #                 "latest_funding_rate": "0",
+        #                 "latest_funding_time": 1715731200000,
+        #                 "mark_price": "61602.22",
+        #                 "market": "BTCUSDT",
+        #                 "max_funding_rate": "0.00375",
+        #                 "min_funding_rate": "-0.00375",
+        #                 "next_funding_rate": "0.00021074",
+        #                 "next_funding_time": 1715760000000
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
         #
-        data = self.safe_value(response, 'data', {})
-        ticker = self.safe_value(data, 'ticker', {})
-        timestamp = self.safe_integer(data, 'date')
-        ticker['timestamp'] = timestamp  # avoid changing parseFundingRate signature
-        return self.parse_funding_rate(ticker, market)
+        data = self.safe_list(response, 'data', [])
+        first = self.safe_dict(data, 0, {})
+        return self.parse_funding_rate(first, market)
 
     def parse_funding_rate(self, contract, market: Market = None):
         #
-        # fetchFundingRate
+        # fetchFundingRate, fetchFundingRates
         #
         #     {
-        #         "vol": "6090.9430",
-        #         "low": "39180.30",
-        #         "open": "40474.97",
-        #         "high": "40798.01",
-        #         "last": "39659.30",
-        #         "buy": "39663.79",
-        #         "period": 86400,
-        #         "funding_time": 372,
-        #         "position_amount": "270.1956",
-        #         "funding_rate_last": "0.00022913",
-        #         "funding_rate_next": "0.00013158",
-        #         "funding_rate_predict": "0.00016552",
-        #         "insurance": "16045554.83969682659674035672",
-        #         "sign_price": "39652.48",
-        #         "index_price": "39648.44250000",
-        #         "sell_total": "22.3913",
-        #         "buy_total": "19.4498",
-        #         "buy_amount": "12.8942",
-        #         "sell": "39663.80",
-        #         "sell_amount": "0.9388"
+        #         "latest_funding_rate": "0",
+        #         "latest_funding_time": 1715731200000,
+        #         "mark_price": "61602.22",
+        #         "market": "BTCUSDT",
+        #         "max_funding_rate": "0.00375",
+        #         "min_funding_rate": "-0.00375",
+        #         "next_funding_rate": "0.00021074",
+        #         "next_funding_time": 1715760000000
         #     }
         #
-        timestamp = self.safe_integer(contract, 'timestamp')
-        contract = self.omit(contract, 'timestamp')
-        fundingDelta = self.safe_integer(contract, 'funding_time') * 60 * 1000
-        fundingHour = (timestamp + fundingDelta) / 3600000
-        fundingTimestamp = int(round(fundingHour)) * 3600000
+        currentFundingTimestamp = self.safe_integer(contract, 'latest_funding_time')
+        futureFundingTimestamp = self.safe_integer(contract, 'next_funding_time')
+        marketId = self.safe_string(contract, 'market')
         return {
             'info': contract,
-            'symbol': self.safe_symbol(None, market),
-            'markPrice': self.safe_number(contract, 'sign_price'),
-            'indexPrice': self.safe_number(contract, 'index_price'),
+            'symbol': self.safe_symbol(marketId, market, None, 'swap'),
+            'markPrice': self.safe_number(contract, 'mark_price'),
+            'indexPrice': None,
             'interestRate': None,
             'estimatedSettlePrice': None,
-            'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'fundingRate': self.safe_number(contract, 'funding_rate_next'),
-            'fundingTimestamp': fundingTimestamp,
-            'fundingDatetime': self.iso8601(fundingTimestamp),
-            'nextFundingRate': self.safe_number(contract, 'funding_rate_predict'),
-            'nextFundingTimestamp': None,
-            'nextFundingDatetime': None,
-            'previousFundingRate': self.safe_number(contract, 'funding_rate_last'),
+            'timestamp': None,
+            'datetime': None,
+            'fundingRate': self.safe_number(contract, 'latest_funding_rate'),
+            'fundingTimestamp': currentFundingTimestamp,
+            'fundingDatetime': self.iso8601(currentFundingTimestamp),
+            'nextFundingRate': self.safe_number(contract, 'next_funding_rate'),
+            'nextFundingTimestamp': futureFundingTimestamp,
+            'nextFundingDatetime': self.iso8601(futureFundingTimestamp),
+            'previousFundingRate': None,
             'previousFundingTimestamp': None,
             'previousFundingDatetime': None,
         }
@@ -4316,65 +4322,43 @@ class coinex(Exchange, ImplicitAPI):
     def fetch_funding_rates(self, symbols: Strings = None, params={}):
         """
         fetch the current funding rates
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http009_market_ticker_all
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate
         :param str[] symbols: unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
         """
         self.load_markets()
         symbols = self.market_symbols(symbols)
+        request = {}
         market = None
         if symbols is not None:
             symbol = self.safe_value(symbols, 0)
             market = self.market(symbol)
             if not market['swap']:
                 raise BadSymbol(self.id + ' fetchFundingRates() supports swap contracts only')
-        response = self.v1PerpetualPublicGetMarketTickerAll(params)
+            marketIds = self.market_ids(symbols)
+            request['market'] = ','.join(marketIds)
+        response = self.v2PublicGetFuturesFundingRate(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data":
-        #         {
-        #             "date": 1650678472474,
-        #             "ticker": {
-        #                 "BTCUSDT": {
-        #                     "vol": "6090.9430",
-        #                     "low": "39180.30",
-        #                     "open": "40474.97",
-        #                     "high": "40798.01",
-        #                     "last": "39659.30",
-        #                     "buy": "39663.79",
-        #                     "period": 86400,
-        #                     "funding_time": 372,
-        #                     "position_amount": "270.1956",
-        #                     "funding_rate_last": "0.00022913",
-        #                     "funding_rate_next": "0.00013158",
-        #                     "funding_rate_predict": "0.00016552",
-        #                     "insurance": "16045554.83969682659674035672",
-        #                     "sign_price": "39652.48",
-        #                     "index_price": "39648.44250000",
-        #                     "sell_total": "22.3913",
-        #                     "buy_total": "19.4498",
-        #                     "buy_amount": "12.8942",
-        #                     "sell": "39663.80",
-        #                     "sell_amount": "0.9388"
-        #                 }
+        #         "data": [
+        #             {
+        #                 "latest_funding_rate": "0",
+        #                 "latest_funding_time": 1715731200000,
+        #                 "mark_price": "61602.22",
+        #                 "market": "BTCUSDT",
+        #                 "max_funding_rate": "0.00375",
+        #                 "min_funding_rate": "-0.00375",
+        #                 "next_funding_rate": "0.00021074",
+        #                 "next_funding_time": 1715760000000
         #             }
-        #         },
+        #         ],
         #         "message": "OK"
         #     }
-        data = self.safe_value(response, 'data', {})
-        tickers = self.safe_value(data, 'ticker', {})
-        timestamp = self.safe_integer(data, 'date')
-        result = []
-        marketIds = list(tickers.keys())
-        for i in range(0, len(marketIds)):
-            marketId = marketIds[i]
-            if marketId.find('_') == -1:  # skip _signprice and _indexprice
-                marketInner = self.safe_market(marketId, None, None, 'swap')
-                ticker = tickers[marketId]
-                ticker['timestamp'] = timestamp
-                result.append(self.parse_funding_rate(ticker, marketInner))
+        #
+        data = self.safe_list(response, 'data', [])
+        result = self.parse_funding_rates(data, market)
         return self.filter_by_array(result, 'symbol', symbols)
 
     def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
@@ -4442,13 +4426,13 @@ class coinex(Exchange, ImplicitAPI):
 
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
-        :see: https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http038_funding_history
         fetches historical funding rate prices
+        :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-funding-rate-history
         :param str symbol: unified symbol of the market to fetch the funding rate history for
         :param int [since]: timestamp in ms of the earliest funding rate to fetch
         :param int [limit]: the maximum amount of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>` to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :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 int [params.until]: timestamp in ms of the latest funding rate
         :returns dict[]: a list of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>`
         """
@@ -4459,50 +4443,44 @@ class coinex(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
         if paginate:
             return self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params, 1000)
-        if limit is None:
-            limit = 100
         market = self.market(symbol)
         request = {
             'market': market['id'],
-            'limit': limit,
-            'offset': 0,
-            # 'end_time': 1638990636,
         }
         if since is not None:
             request['start_time'] = since
+        if limit is not None:
+            request['limit'] = limit
         request, params = self.handle_until_option('end_time', request, params)
-        response = self.v1PerpetualPublicGetMarketFundingHistory(self.extend(request, params))
+        response = self.v2PublicGetFuturesFundingRateHistory(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data": {
-        #             "offset": 0,
-        #             "limit": 3,
-        #             "records": [
-        #                 {
-        #                     "time": 1650672021.6230309,
-        #                     "market": "BTCUSDT",
-        #                     "asset": "USDT",
-        #                     "funding_rate": "0.00022913",
-        #                     "funding_rate_real": "0.00022913"
-        #                 },
-        #             ]
-        #         },
-        #         "message": "OK"
+        #         "data": [
+        #             {
+        #                 "actual_funding_rate": "0",
+        #                 "funding_time": 1715731221761,
+        #                 "market": "BTCUSDT",
+        #                 "theoretical_funding_rate": "0"
+        #             },
+        #         ],
+        #         "message": "OK",
+        #         "pagination": {
+        #             "has_next": True
+        #         }
         #     }
         #
-        data = self.safe_value(response, 'data')
-        result = self.safe_value(data, 'records', [])
+        data = self.safe_list(response, 'data', [])
         rates = []
-        for i in range(0, len(result)):
-            entry = result[i]
+        for i in range(0, len(data)):
+            entry = data[i]
             marketId = self.safe_string(entry, 'market')
             symbolInner = self.safe_symbol(marketId, market, None, 'swap')
-            timestamp = self.safe_timestamp(entry, 'time')
+            timestamp = self.safe_integer(entry, 'funding_time')
             rates.append({
                 'info': entry,
                 'symbol': symbolInner,
-                'fundingRate': self.safe_number(entry, 'funding_rate'),
+                'fundingRate': self.safe_number(entry, 'actual_funding_rate'),
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
             })
@@ -5549,7 +5527,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)

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,
@@ -3608,7 +3638,8 @@ class phemex(Exchange, ImplicitAPI):
                 raise BadRequest(self.id + ' fetchFundingHistory() limit argument cannot exceed 200')
             request['limit'] = limit
         response = None
-        if market['settle'] == 'USDT':
+        isUsdt = market['settle'] == 'USDT'
+        if isUsdt:
             response = self.privateGetApiDataGFuturesFundingFees(self.extend(request, params))
         else:
             response = self.privateGetApiDataFuturesFundingFees(self.extend(request, params))
@@ -3621,13 +3652,13 @@ class phemex(Exchange, ImplicitAPI):
         #                 {
         #                     "symbol": "BTCUSD",
         #                     "currency": "BTC",
-        #                     "execQty": 18,
+        #                     "execQty": 18,  # "execQty" regular, but "execQtyRq" in hedge
         #                     "side": "Buy",
-        #                     "execPriceEp": 360086455,
-        #                     "execValueEv": 49987,
-        #                     "fundingRateEr": 10000,
-        #                     "feeRateEr": 10000,
-        #                     "execFeeEv": 5,
+        #                     "execPriceEp": 360086455,  # "execPriceEp" regular, but "execPriceRp" in hedge
+        #                     "execValueEv": 49987,  # "execValueEv" regular, but "execValueRv" in hedge
+        #                     "fundingRateEr": 10000,  # "fundingRateEr" regular, but "fundingRateRr" in hedge
+        #                     "feeRateEr": 10000,  # "feeRateEr" regular, but "feeRateRr" in hedge
+        #                     "execFeeEv": 5,  # "execFeeEv" regular, but "execFeeRv" in hedge
         #                     "createTime": 1651881600000
         #                 }
         #             ]
@@ -3640,17 +3671,31 @@ class phemex(Exchange, ImplicitAPI):
         for i in range(0, len(rows)):
             entry = rows[i]
             timestamp = self.safe_integer(entry, 'createTime')
+            execFee = self.safe_string_2(entry, 'execFeeEv', 'execFeeRv')
+            currencyCode = self.safe_currency_code(self.safe_string(entry, 'currency'))
             result.append({
                 'info': entry,
                 'symbol': self.safe_string(entry, 'symbol'),
-                'code': self.safe_currency_code(self.safe_string(entry, 'currency')),
+                'code': currencyCode,
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),
                 'id': None,
-                'amount': self.from_ev(self.safe_string(entry, 'execFeeEv'), market),
+                'amount': self.parse_funding_fee_to_precision(execFee, market, currencyCode),
             })
         return result
 
+    def parse_funding_fee_to_precision(self, value, market: Market = None, currencyCode: Str = None):
+        if value is None or currencyCode is None:
+            return value
+        # it was confirmed by phemex support, that USDT contracts use direct amounts in funding fees, while USD & INVERSE needs 'valueScale'
+        isUsdt = market['settle'] == 'USDT'
+        if not isUsdt:
+            currency = self.safe_currency(currencyCode)
+            scale = self.safe_string(currency['info'], 'valueScale')
+            tickPrecision = self.parse_precision(scale)
+            value = Precise.string_mul(value, tickPrecision)
+        return value
+
     def fetch_funding_rate(self, symbol: str, params={}):
         """
         fetch the current funding rate

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.21'
+__version__ = '4.3.23'
 
 # ----------------------------------------------------------------------------