[Trades] add get_real_or_estimated_trade_fee

Author: GuillaumeDSM

octobot_trading/personal_data/__init__.py

@@ -223,6 +223,7 @@
     TradePnl,
     compute_win_rate,
     aggregate_trades_by_exchange_order_id,
+    get_real_or_estimated_trade_fee,
 )
 from octobot_trading.personal_data import transactions
 from octobot_trading.personal_data.transactions import (
@@ -458,6 +459,7 @@
     "TradePnl",
     "compute_win_rate",
     "aggregate_trades_by_exchange_order_id",
+    "get_real_or_estimated_trade_fee",
     "ExchangePersonalData",
     "get_asset_price_from_converter_or_tickers",
     "resolve_sub_portfolios",

octobot_trading/personal_data/trades/__init__.py

@@ -42,6 +42,7 @@
 from octobot_trading.personal_data.trades.trades_util import (
     compute_win_rate,
     aggregate_trades_by_exchange_order_id,
+    get_real_or_estimated_trade_fee,
 )
 
 __all__ = [
@@ -57,4 +58,5 @@
     "TradePnl",
     "compute_win_rate",
     "aggregate_trades_by_exchange_order_id",
+    "get_real_or_estimated_trade_fee",
 ]

octobot_trading/personal_data/trades/trade.py

@@ -176,6 +176,9 @@ def from_dict(cls, trader, trade_dict):
         trade.creation_time = trade_dict.get(enums.TradeExtraConstants.CREATION_TIME.value)
         return trade
 
+    def duplicate(self):
+        return self.__class__.from_dict(self.trader, self.to_dict())
+
     def clear(self):
         self.trader = None # type: ignore
         self.exchange_manager = None # type: ignore

octobot_trading/personal_data/trades/trade_factory.py

@@ -13,20 +13,23 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import typing
+
 import octobot_commons.logging as logging
 import octobot_trading.personal_data.trades.trade as trade_class
+import octobot_trading.personal_data.orders.order as order_class
 import octobot_trading.personal_data.orders.order_factory as order_factory
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
 
 
-def create_trade_instance_from_raw(trader, raw_trade):
+def create_trade_instance_from_raw(trader, raw_trade: dict[str, typing.Any]) -> "trade_class.Trade":
     order = create_closed_order_instance_from_raw_trade(trader, raw_trade)
     exchange_trade_id = raw_trade.get(enums.ExchangeConstantsOrderColumns.EXCHANGE_TRADE_ID.value)
     return create_trade_from_order(order, exchange_trade_id=exchange_trade_id)
 
 
-def create_closed_order_instance_from_raw_trade(trader, raw_trade):
+def create_closed_order_instance_from_raw_trade(trader, raw_trade: dict[str, typing.Any]) -> "order_class.Order":
     order = order_factory.create_order_from_raw(trader, raw_trade)
     order.update_from_raw(raw_trade)
     if order.status is enums.OrderStatus.CANCELED:
@@ -38,12 +41,12 @@ def create_closed_order_instance_from_raw_trade(trader, raw_trade):
     return order
 
 
-def create_trade_from_order(order,
-                            close_status=None,
-                            creation_time=0,
-                            canceled_time=0,
-                            executed_time=0,
-                            exchange_trade_id=None):
+def create_trade_from_order(order: "order_class.Order",
+                            close_status: typing.Optional[enums.OrderStatus] = None,
+                            creation_time: int = 0,
+                            canceled_time: int = 0,
+                            executed_time: int = 0,
+                            exchange_trade_id: typing.Optional[str] = None) -> "trade_class.Trade":
     if close_status is not None:
         order.status = close_status
     trade = trade_class.Trade(order.trader)
@@ -58,5 +61,5 @@ def create_trade_from_order(order,
     return trade
 
 
-def create_trade_from_dict(trader, trade_dict):
+def create_trade_from_dict(trader, trade_dict: dict[str, typing.Any]) -> "trade_class.Trade":
     return trade_class.Trade.from_dict(trader, trade_dict)

octobot_trading/personal_data/trades/trades_util.py

@@ -15,6 +15,7 @@
 #  License along with this library.
 import decimal
 
+import octobot_commons.symbols as symbols_util
 import octobot_trading.enums as trading_enums
 import octobot_trading.constants as constants
 import octobot_trading.personal_data as personal_data
@@ -93,3 +94,67 @@ def aggregate_trades_by_exchange_order_id(trades: list) -> dict:
                 += trade.fee[trading_enums.FeePropertyColumns.COST.value]
             to_update.executed_time = max(to_update.executed_time, trade.executed_time)
     return aggregated_trades_by_exchange_order_id
+
+
+def get_real_or_estimated_trade_fee(trade: "personal_data.Trade") -> tuple[dict, bool]:
+    order_type = trading_enums.TraderOrderType.BUY_LIMIT if trade.side is trading_enums.TradeOrderSide.BUY else trading_enums.TraderOrderType.SELL_LIMIT
+    trading_order_fee_currency = None
+    trading_order_fee_rate = None
+    is_estimated_trading_fee = False
+    if trade.fee and all(
+        key.value in trade.fee for key in [
+            trading_enums.FeePropertyColumns.CURRENCY, trading_enums.FeePropertyColumns.RATE
+        ]
+    ):
+        trading_order_fee_currency = trade.fee[trading_enums.FeePropertyColumns.CURRENCY.value]
+        trading_order_fee_rate = trade.fee[trading_enums.FeePropertyColumns.RATE.value]
+    else:
+        # try to get fees from somewhere else
+        try:
+            # check if order has fees
+            order = trade.exchange_manager.exchange_personal_data.orders_manager.get_order(
+                None, exchange_order_id=trade.exchange_order_id
+            )
+            if not order.fee or not all(
+                key.value in order.fee for key in [
+                    trading_enums.FeePropertyColumns.CURRENCY, trading_enums.FeePropertyColumns.RATE
+                ]
+            ):
+                raise KeyError("no fee")
+            trading_order_fee_currency = order.fee[trading_enums.FeePropertyColumns.CURRENCY.value]
+            trading_order_fee_rate = order.fee[trading_enums.FeePropertyColumns.RATE.value]
+        except KeyError:
+            # try with other trades from the same order
+            trades = trade.exchange_manager.exchange_personal_data.trades_manager.get_trades(
+                None, exchange_order_id=trade.exchange_order_id
+            )
+            for other_trade in trades:
+                if not other_trade.fee or not all(
+                    key.value in other_trade.fee for key in [
+                        trading_enums.FeePropertyColumns.CURRENCY, trading_enums.FeePropertyColumns.RATE
+                    ]
+                ):
+                    continue
+                trading_order_fee_currency = other_trade.fee[trading_enums.FeePropertyColumns.CURRENCY.value]
+                trading_order_fee_rate = other_trade.fee[trading_enums.FeePropertyColumns.RATE.value]
+
+    if trading_order_fee_currency and trading_order_fee_rate:
+        base, quote = symbols_util.parse_symbol(trade.symbol).base_and_quote()
+        if trading_order_fee_currency == base:
+            trading_order_fee_cost = trading_order_fee_rate * trade.executed_quantity
+        elif trading_order_fee_currency == quote:
+            trading_order_fee_cost = trading_order_fee_rate * trade.executed_quantity * trade.executed_price
+        else:
+            # fee currency is not the base or quote of the symbol
+            trading_order_fee_cost = constants.ZERO
+        trading_fee = {
+            trading_enums.FeePropertyColumns.CURRENCY.value: trading_order_fee_currency,
+            trading_enums.FeePropertyColumns.COST.value: trading_order_fee_cost,
+        }
+    else:
+        # estimate fees
+        trading_fee = trade.exchange_manager.exchange.get_trade_fee(
+            trade.symbol, order_type, trade.executed_quantity, trade.executed_price, trade.taker_or_maker
+        )
+        is_estimated_trading_fee = True
+    return trading_fee, is_estimated_trading_fee