From c58a1649cb0d016cd3996e31d5ca582a7eb98424 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 20:18:19 +0200
Subject: [PATCH 1/8] add calc_profit_combined call

---
 freqtrade/persistence/trade_model.py  | 46 +++++++++++++++++++++++++++
 tests/persistence/test_persistence.py | 15 +++++++++
 2 files changed, 61 insertions(+)

diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index 6f31444d4..705fc5d7b 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -905,6 +905,52 @@ class LocalTrade:
             profit = close_trade_value - open_trade_value
         return float(f"{profit:.8f}")
 
+    def calc_profit_combined(self, rate: float, amount: Optional[float] = None,
+                             open_rate: Optional[float] = None):
+        """
+        Calculate profit metrics (absolute, ratio, total, total ratio).
+        All calculations include fees.
+        :param rate: close rate to compare with.
+        :param amount: Amount to use for the calculation. Falls back to trade.amount if not set.
+        :param open_rate: open_rate to use. Defaults to self.open_rate if not provided.
+        :return: TODO: fill me out
+        """
+
+        close_trade_value = self.calc_close_trade_value(rate, amount)
+        if amount is None or open_rate is None:
+            open_trade_value = self.open_trade_value
+        else:
+            open_trade_value = self._calc_open_trade_value(amount, open_rate)
+
+        if self.is_short:
+            profit_abs = open_trade_value - close_trade_value
+        else:
+            profit_abs = close_trade_value - open_trade_value
+
+        try:
+            if self.is_short:
+                profit_ratio = (1 - (close_trade_value / open_trade_value)) * self.leverage
+            else:
+                profit_ratio = ((close_trade_value / open_trade_value) - 1) * self.leverage
+            profit_ratio = float(f"{profit_ratio:.8f}")
+        except ZeroDivisionError:
+            profit_ratio = 0.0
+
+        total_profit_abs = profit_abs + self.realized_profit
+        total_profit_ratio = (
+            (total_profit_abs / self.max_stake_amount) * self.leverage
+            if self.max_stake_amount else 0.0
+        )
+        total_profit_ratio = float(f"{total_profit_ratio:.8f}")
+        profit_abs = float(f"{profit_abs:.8f}")
+        res = {
+            'profit_abs': profit_abs,
+            'profit_ratio': profit_ratio,
+            'total_profit': profit_abs + self.realized_profit,
+            'total_profit_ratio': total_profit_ratio,
+        }
+        return res
+
     def calc_profit_ratio(
             self, rate: float, amount: Optional[float] = None,
             open_rate: Optional[float] = None) -> float:
diff --git a/tests/persistence/test_persistence.py b/tests/persistence/test_persistence.py
index e4802da87..d69d986cc 100644
--- a/tests/persistence/test_persistence.py
+++ b/tests/persistence/test_persistence.py
@@ -1152,14 +1152,29 @@ def test_calc_profit(
         leverage=lev,
         fee_open=0.0025,
         fee_close=fee_close,
+        max_stake_amount=60.0,
         trading_mode=trading_mode,
         funding_fees=funding_fees
     )
     trade.open_order_id = 'something'
 
+    profit_res = trade.calc_profit_combined(close_rate)
+    assert pytest.approx(profit_res['profit_abs']) == round(profit, 8)
+    assert pytest.approx(profit_res['profit_ratio']) == round(profit_ratio, 8)
+
+    assert pytest.approx(profit_res['total_profit']) == round(profit, 8)
+    # assert pytest.approx(profit_res['total_profit_ratio']) == round(profit_ratio, 8)
+
     assert pytest.approx(trade.calc_profit(rate=close_rate)) == round(profit, 8)
     assert pytest.approx(trade.calc_profit_ratio(rate=close_rate)) == round(profit_ratio, 8)
 
+    profit_res2 = trade.calc_profit_combined(close_rate, trade.amount, trade.open_rate)
+    assert pytest.approx(profit_res2['profit_abs']) == round(profit, 8)
+    assert pytest.approx(profit_res2['profit_ratio']) == round(profit_ratio, 8)
+
+    assert pytest.approx(profit_res2['total_profit']) == round(profit, 8)
+    # assert pytest.approx(profit_res2['total_profit_ratio']) == round(profit_ratio, 8)
+
     assert pytest.approx(trade.calc_profit(close_rate, trade.amount,
                          trade.open_rate)) == round(profit, 8)
     assert pytest.approx(trade.calc_profit_ratio(close_rate, trade.amount,

From 28e685ee2be21871b00918a5577fe755be56f51c Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 20:47:06 +0200
Subject: [PATCH 2/8] Switch combined profit response to dataclass

---
 freqtrade/persistence/trade_model.py  | 27 ++++++++++++++++++---------
 tests/persistence/test_persistence.py | 16 ++++++++--------
 2 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index 705fc5d7b..817a8d06b 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -3,6 +3,7 @@ This module contains the class to persist trades into SQLite
 """
 import logging
 from collections import defaultdict
+from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from math import isclose
 from typing import Any, ClassVar, Dict, List, Optional, Sequence, cast
@@ -26,6 +27,14 @@ from freqtrade.util import FtPrecise, dt_now
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class ProfitStruct:
+    profit_abs: float
+    profit_ratio: float
+    total_profit: float
+    total_profit_ratio: float
+
+
 class Order(ModelBase):
     """
     Order database model
@@ -906,14 +915,14 @@ class LocalTrade:
         return float(f"{profit:.8f}")
 
     def calc_profit_combined(self, rate: float, amount: Optional[float] = None,
-                             open_rate: Optional[float] = None):
+                             open_rate: Optional[float] = None) -> ProfitStruct:
         """
         Calculate profit metrics (absolute, ratio, total, total ratio).
         All calculations include fees.
         :param rate: close rate to compare with.
         :param amount: Amount to use for the calculation. Falls back to trade.amount if not set.
         :param open_rate: open_rate to use. Defaults to self.open_rate if not provided.
-        :return: TODO: fill me out
+        :return: Profit structure, containing absolute and relative profits.
         """
 
         close_trade_value = self.calc_close_trade_value(rate, amount)
@@ -943,13 +952,13 @@ class LocalTrade:
         )
         total_profit_ratio = float(f"{total_profit_ratio:.8f}")
         profit_abs = float(f"{profit_abs:.8f}")
-        res = {
-            'profit_abs': profit_abs,
-            'profit_ratio': profit_ratio,
-            'total_profit': profit_abs + self.realized_profit,
-            'total_profit_ratio': total_profit_ratio,
-        }
-        return res
+
+        return ProfitStruct(
+            profit_abs=profit_abs,
+            profit_ratio=profit_ratio,
+            total_profit=profit_abs + self.realized_profit,
+            total_profit_ratio=total_profit_ratio,
+        )
 
     def calc_profit_ratio(
             self, rate: float, amount: Optional[float] = None,
diff --git a/tests/persistence/test_persistence.py b/tests/persistence/test_persistence.py
index d69d986cc..692c50659 100644
--- a/tests/persistence/test_persistence.py
+++ b/tests/persistence/test_persistence.py
@@ -1159,21 +1159,21 @@ def test_calc_profit(
     trade.open_order_id = 'something'
 
     profit_res = trade.calc_profit_combined(close_rate)
-    assert pytest.approx(profit_res['profit_abs']) == round(profit, 8)
-    assert pytest.approx(profit_res['profit_ratio']) == round(profit_ratio, 8)
+    assert pytest.approx(profit_res.profit_abs) == round(profit, 8)
+    assert pytest.approx(profit_res.profit_ratio) == round(profit_ratio, 8)
 
-    assert pytest.approx(profit_res['total_profit']) == round(profit, 8)
-    # assert pytest.approx(profit_res['total_profit_ratio']) == round(profit_ratio, 8)
+    assert pytest.approx(profit_res.total_profit) == round(profit, 8)
+    # assert pytest.approx(profit_res.total_profit_ratio) == round(profit_ratio, 8)
 
     assert pytest.approx(trade.calc_profit(rate=close_rate)) == round(profit, 8)
     assert pytest.approx(trade.calc_profit_ratio(rate=close_rate)) == round(profit_ratio, 8)
 
     profit_res2 = trade.calc_profit_combined(close_rate, trade.amount, trade.open_rate)
-    assert pytest.approx(profit_res2['profit_abs']) == round(profit, 8)
-    assert pytest.approx(profit_res2['profit_ratio']) == round(profit_ratio, 8)
+    assert pytest.approx(profit_res2.profit_abs) == round(profit, 8)
+    assert pytest.approx(profit_res2.profit_ratio) == round(profit_ratio, 8)
 
-    assert pytest.approx(profit_res2['total_profit']) == round(profit, 8)
-    # assert pytest.approx(profit_res2['total_profit_ratio']) == round(profit_ratio, 8)
+    assert pytest.approx(profit_res2.total_profit) == round(profit, 8)
+    # assert pytest.approx(profit_res2.total_profit_ratio) == round(profit_ratio, 8)
 
     assert pytest.approx(trade.calc_profit(close_rate, trade.amount,
                          trade.open_rate)) == round(profit, 8)

From 459b9d80d44aad8ada7f4f5466ccb82ad4083fab Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 21:06:32 +0200
Subject: [PATCH 3/8] use calc_profit_combined

---
 freqtrade/freqtradebot.py            | 21 +++++++++------------
 freqtrade/persistence/trade_model.py | 11 ++++-------
 2 files changed, 13 insertions(+), 19 deletions(-)

diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index 58cc8f862..ac75d8411 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -1731,14 +1731,12 @@ class FreqtradeBot(LoggingMixin):
             amount = order.safe_filled if fill else order.safe_amount
             order_rate: float = order.safe_price
 
-            profit = trade.calc_profit(rate=order_rate, amount=amount, open_rate=trade.open_rate)
-            profit_ratio = trade.calc_profit_ratio(order_rate, amount, trade.open_rate)
+            profit = trade.calc_profit_combined(order_rate, amount, trade.open_rate)
         else:
             order_rate = trade.safe_close_rate
-            profit = trade.calc_profit(rate=order_rate) + (0.0 if fill else trade.realized_profit)
-            profit_ratio = trade.calc_profit_ratio(order_rate)
+            profit = trade.calc_profit_combined(rate=order_rate)
             amount = trade.amount
-        gain = "profit" if profit_ratio > 0 else "loss"
+        gain = "profit" if profit.profit_ratio > 0 else "loss"
 
         msg: RPCSellMsg = {
             'type': (RPCMessageType.EXIT_FILL if fill
@@ -1756,8 +1754,8 @@ class FreqtradeBot(LoggingMixin):
             'open_rate': trade.open_rate,
             'close_rate': order_rate,
             'current_rate': current_rate,
-            'profit_amount': profit,
-            'profit_ratio': profit_ratio,
+            'profit_amount': profit.profit_abs if fill else profit.total_profit,
+            'profit_ratio': profit.profit_ratio,
             'buy_tag': trade.enter_tag,
             'enter_tag': trade.enter_tag,
             'sell_reason': trade.exit_reason,  # Deprecated
@@ -1789,11 +1787,10 @@ class FreqtradeBot(LoggingMixin):
         order = self.order_obj_or_raise(order_id, order_or_none)
 
         profit_rate: float = trade.safe_close_rate
-        profit_trade = trade.calc_profit(rate=profit_rate)
+        profit = trade.calc_profit_combined(rate=profit_rate)
         current_rate = self.exchange.get_rate(
             trade.pair, side='exit', is_short=trade.is_short, refresh=False)
-        profit_ratio = trade.calc_profit_ratio(profit_rate)
-        gain = "profit" if profit_ratio > 0 else "loss"
+        gain = "profit" if profit.profit_ratio > 0 else "loss"
 
         msg: RPCSellCancelMsg = {
             'type': RPCMessageType.EXIT_CANCEL,
@@ -1808,8 +1805,8 @@ class FreqtradeBot(LoggingMixin):
             'amount': order.safe_amount_after_fee,
             'open_rate': trade.open_rate,
             'current_rate': current_rate,
-            'profit_amount': profit_trade,
-            'profit_ratio': profit_ratio,
+            'profit_amount': profit.profit_abs,
+            'profit_ratio': profit.profit_ratio,
             'buy_tag': trade.enter_tag,
             'enter_tag': trade.enter_tag,
             'sell_reason': trade.exit_reason,  # Deprecated
diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index 817a8d06b..e199dded8 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -999,7 +999,6 @@ class LocalTrade:
         avg_price = FtPrecise(0.0)
         close_profit = 0.0
         close_profit_abs = 0.0
-        profit = None
         # Reset funding fees
         self.funding_fees = 0.0
         funding_fees = 0.0
@@ -1029,11 +1028,9 @@ class LocalTrade:
 
                 exit_rate = o.safe_price
                 exit_amount = o.safe_amount_after_fee
-                profit = self.calc_profit(rate=exit_rate, amount=exit_amount,
-                                          open_rate=float(avg_price))
-                close_profit_abs += profit
-                close_profit = self.calc_profit_ratio(
-                    exit_rate, amount=exit_amount, open_rate=avg_price)
+                prof = self.calc_profit_combined(exit_rate, exit_amount, float(avg_price))
+                close_profit_abs += prof.profit_abs
+                close_profit = prof.profit_ratio
             else:
                 total_stake = total_stake + self._calc_open_trade_value(tmp_amount, price)
                 max_stake_amount += (tmp_amount * price)
@@ -1043,7 +1040,7 @@ class LocalTrade:
         if close_profit:
             self.close_profit = close_profit
             self.realized_profit = close_profit_abs
-            self.close_profit_abs = profit
+            self.close_profit_abs = prof.profit_abs
 
         current_amount_tr = amount_to_contract_precision(
             float(current_amount), self.amount_precision, self.precision_mode, self.contract_size)

From 399f144c2754cb3cd6421186b9a749e82da56db7 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 21:29:36 +0200
Subject: [PATCH 4/8] more calc_profit_combined usage

---
 freqtrade/rpc/rpc.py  | 28 ++++++++++++++++------------
 tests/rpc/test_rpc.py |  2 +-
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index 497bc1c82..f0b5d2463 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -174,6 +174,8 @@ class RPC:
                 order: Optional[Order] = None
                 current_profit_fiat: Optional[float] = None
                 total_profit_fiat: Optional[float] = None
+                total_profit_abs = 0.0
+                total_profit_ratio: Optional[float] = None
                 if trade.open_order_id:
                     order = trade.select_order_by_order_id(trade.open_order_id)
                 # calculate profit and send message to user
@@ -184,23 +186,22 @@ class RPC:
                     except (ExchangeError, PricingError):
                         current_rate = NAN
                     if len(trade.select_filled_orders(trade.entry_side)) > 0:
-                        current_profit = trade.calc_profit_ratio(
-                            current_rate) if not isnan(current_rate) else NAN
-                        current_profit_abs = trade.calc_profit(
-                            current_rate) if not isnan(current_rate) else NAN
+
+                        current_profit = current_profit_abs = current_profit_fiat = NAN
+                        if not isnan(current_rate):
+                            prof = trade.calc_profit_combined(current_rate)
+                            current_profit = prof.profit_ratio
+                            current_profit_abs = prof.profit_abs
+                            total_profit_abs = prof.total_profit
+                            total_profit_ratio = prof.total_profit_ratio
                     else:
                         current_profit = current_profit_abs = current_profit_fiat = 0.0
+
                 else:
                     # Closed trade ...
                     current_rate = trade.close_rate
                     current_profit = trade.close_profit or 0.0
                     current_profit_abs = trade.close_profit_abs or 0.0
-                total_profit_abs = trade.realized_profit + current_profit_abs
-                total_profit_ratio: Optional[float] = None
-                if trade.max_stake_amount:
-                    total_profit_ratio = (
-                        (total_profit_abs / trade.max_stake_amount) * trade.leverage
-                    )
 
                 # Calculate fiat profit
                 if not isnan(current_profit_abs) and self._fiat_converter:
@@ -216,8 +217,11 @@ class RPC:
                     )
 
                 # Calculate guaranteed profit (in case of trailing stop)
-                stoploss_entry_dist = trade.calc_profit(trade.stop_loss)
-                stoploss_entry_dist_ratio = trade.calc_profit_ratio(trade.stop_loss)
+                stop_entry = trade.calc_profit_combined(trade.stop_loss)
+
+                stoploss_entry_dist = stop_entry.profit_abs
+                stoploss_entry_dist_ratio = stop_entry.profit_ratio
+
                 # calculate distance to stoploss
                 stoploss_current_dist = trade.stop_loss - current_rate
                 stoploss_current_dist_ratio = stoploss_current_dist / current_rate
diff --git a/tests/rpc/test_rpc.py b/tests/rpc/test_rpc.py
index d97222adc..70341b37e 100644
--- a/tests/rpc/test_rpc.py
+++ b/tests/rpc/test_rpc.py
@@ -164,7 +164,7 @@ def test_rpc_trade_status(default_conf, ticker, fee, mocker) -> None:
     response = deepcopy(gen_response)
     response.update({
         'max_stake_amount': 0.001,
-        'total_profit_ratio': pytest.approx(-0.00409),
+        'total_profit_ratio': pytest.approx(-0.00409153),
     })
     assert results[0] == response
 

From ffb1cf52b174bdfae605a96f26d72c19c7415284 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 21:35:03 +0200
Subject: [PATCH 5/8] Convert further usages to calc_profit_combined

---
 freqtrade/rpc/rpc.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index f0b5d2463..e69fbee04 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -271,8 +271,9 @@ class RPC:
                     profit_str = f'{NAN:.2%}'
                 else:
                     if trade.nr_of_successful_entries > 0:
-                        trade_profit = trade.calc_profit(current_rate)
-                        profit_str = f'{trade.calc_profit_ratio(current_rate):.2%}'
+                        profit = trade.calc_profit_combined(current_rate)
+                        trade_profit = profit.profit_abs
+                        profit_str = f'{profit.profit_ratio:.2%}'
                     else:
                         trade_profit = 0.0
                         profit_str = f'{0.0:.2f}'
@@ -491,9 +492,10 @@ class RPC:
                     profit_ratio = NAN
                     profit_abs = NAN
                 else:
-                    profit_ratio = trade.calc_profit_ratio(rate=current_rate)
-                    profit_abs = trade.calc_profit(
-                        rate=trade.close_rate or current_rate) + trade.realized_profit
+                    profit = trade.calc_profit_combined(trade.close_rate or current_rate)
+
+                    profit_ratio = profit.profit_ratio
+                    profit_abs = profit.total_profit
 
             profit_all_coin.append(profit_abs)
             profit_all_ratio.append(profit_ratio)

From fac8e0fde5c3b82debd061dc4865cf157876b68b Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 21:36:52 +0200
Subject: [PATCH 6/8] Remove calc_profit content

---
 freqtrade/persistence/trade_model.py | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index e199dded8..9989d30d4 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -897,22 +897,14 @@ class LocalTrade:
                     open_rate: Optional[float] = None) -> float:
         """
         Calculate the absolute profit in stake currency between Close and Open trade
+        Deprecated - only available for backwards compatibility
         :param rate: close rate to compare with.
         :param amount: Amount to use for the calculation. Falls back to trade.amount if not set.
         :param open_rate: open_rate to use. Defaults to self.open_rate if not provided.
         :return: profit in stake currency as float
         """
-        close_trade_value = self.calc_close_trade_value(rate, amount)
-        if amount is None or open_rate is None:
-            open_trade_value = self.open_trade_value
-        else:
-            open_trade_value = self._calc_open_trade_value(amount, open_rate)
-
-        if self.is_short:
-            profit = open_trade_value - close_trade_value
-        else:
-            profit = close_trade_value - open_trade_value
-        return float(f"{profit:.8f}")
+        prof = self.calc_profit_combined(rate, amount, open_rate)
+        return prof.profit_abs
 
     def calc_profit_combined(self, rate: float, amount: Optional[float] = None,
                              open_rate: Optional[float] = None) -> ProfitStruct:

From 07e07bd66b2272dabba813c07eea63d65835e445 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Tue, 29 Aug 2023 21:58:15 +0200
Subject: [PATCH 7/8] Improve test, ensuring we calculate profits correctly

---
 tests/persistence/test_persistence.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/persistence/test_persistence.py b/tests/persistence/test_persistence.py
index 692c50659..23e5398d0 100644
--- a/tests/persistence/test_persistence.py
+++ b/tests/persistence/test_persistence.py
@@ -1161,6 +1161,8 @@ def test_calc_profit(
     profit_res = trade.calc_profit_combined(close_rate)
     assert pytest.approx(profit_res.profit_abs) == round(profit, 8)
     assert pytest.approx(profit_res.profit_ratio) == round(profit_ratio, 8)
+    val = trade.open_trade_value * (profit_res.profit_ratio) / lev
+    assert pytest.approx(val) == profit_res.profit_abs
 
     assert pytest.approx(profit_res.total_profit) == round(profit, 8)
     # assert pytest.approx(profit_res.total_profit_ratio) == round(profit_ratio, 8)

From 39b6a00224d5755b920519b64fb90feeb6383fd2 Mon Sep 17 00:00:00 2001
From: Matthias <xmatthias@outlook.com>
Date: Mon, 4 Sep 2023 06:42:16 +0200
Subject: [PATCH 8/8] Improve naming of calculate_profit method

---
 freqtrade/freqtradebot.py             | 6 +++---
 freqtrade/persistence/trade_model.py  | 8 ++++----
 freqtrade/rpc/rpc.py                  | 8 ++++----
 tests/persistence/test_persistence.py | 4 ++--
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/freqtrade/freqtradebot.py b/freqtrade/freqtradebot.py
index ac75d8411..e326d59b7 100644
--- a/freqtrade/freqtradebot.py
+++ b/freqtrade/freqtradebot.py
@@ -1731,10 +1731,10 @@ class FreqtradeBot(LoggingMixin):
             amount = order.safe_filled if fill else order.safe_amount
             order_rate: float = order.safe_price
 
-            profit = trade.calc_profit_combined(order_rate, amount, trade.open_rate)
+            profit = trade.calculate_profit(order_rate, amount, trade.open_rate)
         else:
             order_rate = trade.safe_close_rate
-            profit = trade.calc_profit_combined(rate=order_rate)
+            profit = trade.calculate_profit(rate=order_rate)
             amount = trade.amount
         gain = "profit" if profit.profit_ratio > 0 else "loss"
 
@@ -1787,7 +1787,7 @@ class FreqtradeBot(LoggingMixin):
         order = self.order_obj_or_raise(order_id, order_or_none)
 
         profit_rate: float = trade.safe_close_rate
-        profit = trade.calc_profit_combined(rate=profit_rate)
+        profit = trade.calculate_profit(rate=profit_rate)
         current_rate = self.exchange.get_rate(
             trade.pair, side='exit', is_short=trade.is_short, refresh=False)
         gain = "profit" if profit.profit_ratio > 0 else "loss"
diff --git a/freqtrade/persistence/trade_model.py b/freqtrade/persistence/trade_model.py
index 9989d30d4..cb5816d4e 100644
--- a/freqtrade/persistence/trade_model.py
+++ b/freqtrade/persistence/trade_model.py
@@ -903,11 +903,11 @@ class LocalTrade:
         :param open_rate: open_rate to use. Defaults to self.open_rate if not provided.
         :return: profit in stake currency as float
         """
-        prof = self.calc_profit_combined(rate, amount, open_rate)
+        prof = self.calculate_profit(rate, amount, open_rate)
         return prof.profit_abs
 
-    def calc_profit_combined(self, rate: float, amount: Optional[float] = None,
-                             open_rate: Optional[float] = None) -> ProfitStruct:
+    def calculate_profit(self, rate: float, amount: Optional[float] = None,
+                         open_rate: Optional[float] = None) -> ProfitStruct:
         """
         Calculate profit metrics (absolute, ratio, total, total ratio).
         All calculations include fees.
@@ -1020,7 +1020,7 @@ class LocalTrade:
 
                 exit_rate = o.safe_price
                 exit_amount = o.safe_amount_after_fee
-                prof = self.calc_profit_combined(exit_rate, exit_amount, float(avg_price))
+                prof = self.calculate_profit(exit_rate, exit_amount, float(avg_price))
                 close_profit_abs += prof.profit_abs
                 close_profit = prof.profit_ratio
             else:
diff --git a/freqtrade/rpc/rpc.py b/freqtrade/rpc/rpc.py
index e69fbee04..23f9eac4c 100644
--- a/freqtrade/rpc/rpc.py
+++ b/freqtrade/rpc/rpc.py
@@ -189,7 +189,7 @@ class RPC:
 
                         current_profit = current_profit_abs = current_profit_fiat = NAN
                         if not isnan(current_rate):
-                            prof = trade.calc_profit_combined(current_rate)
+                            prof = trade.calculate_profit(current_rate)
                             current_profit = prof.profit_ratio
                             current_profit_abs = prof.profit_abs
                             total_profit_abs = prof.total_profit
@@ -217,7 +217,7 @@ class RPC:
                     )
 
                 # Calculate guaranteed profit (in case of trailing stop)
-                stop_entry = trade.calc_profit_combined(trade.stop_loss)
+                stop_entry = trade.calculate_profit(trade.stop_loss)
 
                 stoploss_entry_dist = stop_entry.profit_abs
                 stoploss_entry_dist_ratio = stop_entry.profit_ratio
@@ -271,7 +271,7 @@ class RPC:
                     profit_str = f'{NAN:.2%}'
                 else:
                     if trade.nr_of_successful_entries > 0:
-                        profit = trade.calc_profit_combined(current_rate)
+                        profit = trade.calculate_profit(current_rate)
                         trade_profit = profit.profit_abs
                         profit_str = f'{profit.profit_ratio:.2%}'
                     else:
@@ -492,7 +492,7 @@ class RPC:
                     profit_ratio = NAN
                     profit_abs = NAN
                 else:
-                    profit = trade.calc_profit_combined(trade.close_rate or current_rate)
+                    profit = trade.calculate_profit(trade.close_rate or current_rate)
 
                     profit_ratio = profit.profit_ratio
                     profit_abs = profit.total_profit
diff --git a/tests/persistence/test_persistence.py b/tests/persistence/test_persistence.py
index 23e5398d0..8f5accdb4 100644
--- a/tests/persistence/test_persistence.py
+++ b/tests/persistence/test_persistence.py
@@ -1158,7 +1158,7 @@ def test_calc_profit(
     )
     trade.open_order_id = 'something'
 
-    profit_res = trade.calc_profit_combined(close_rate)
+    profit_res = trade.calculate_profit(close_rate)
     assert pytest.approx(profit_res.profit_abs) == round(profit, 8)
     assert pytest.approx(profit_res.profit_ratio) == round(profit_ratio, 8)
     val = trade.open_trade_value * (profit_res.profit_ratio) / lev
@@ -1170,7 +1170,7 @@ def test_calc_profit(
     assert pytest.approx(trade.calc_profit(rate=close_rate)) == round(profit, 8)
     assert pytest.approx(trade.calc_profit_ratio(rate=close_rate)) == round(profit_ratio, 8)
 
-    profit_res2 = trade.calc_profit_combined(close_rate, trade.amount, trade.open_rate)
+    profit_res2 = trade.calculate_profit(close_rate, trade.amount, trade.open_rate)
     assert pytest.approx(profit_res2.profit_abs) == round(profit, 8)
     assert pytest.approx(profit_res2.profit_ratio) == round(profit_ratio, 8)