OctoBot-Trading 2.4.202__tar.gz → 2.4.204__tar.gz

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.204] - 2025-08-04
+### Updated
+[SubPortfolio] handle local exchange symbols fees
+
+## [2.4.203] - 2025-08-03
+### Updated
+[Trades] log parsing error
+
 ## [2.4.202] - 2025-08-01
 ### Added
 [Exchange] add skipped_create_order_retry context manager

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.202
+Version: 2.4.204
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.202](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.204](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.202/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.204}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.202
+Version: 2.4.204
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.202](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.204](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.202](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.204](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/__init__.py

@@ -15,4 +15,4 @@
 #  License along with this library.
 
 PROJECT_NAME = "OctoBot-Trading"
-VERSION = "2.4.202"  # major.minor.revision
+VERSION = "2.4.204"  # major.minor.revision

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/exchanges/types/rest_exchange.py

@@ -139,6 +139,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to an order that can't be cancelled on exchange (because filled or already cancelled)
     EXCHANGE_ORDER_UNCANCELLABLE_ERRORS: typing.List[typing.Iterable[str]] = []
+    # set when the exchange can allow users to pay fees in a custom currency (ex: BNB on binance)
+    LOCAL_FEES_CURRENCIES: typing.List[str] = []
 
     DEFAULT_CONNECTOR_CLASS = ccxt_connector.CCXTConnector
 

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -609,10 +609,18 @@ def get_portfolio_filled_orders_deltas(
             if (
                 # try while taking possible fees into account
                 asset_name in possible_fees_asset_deltas and (
-                    abs(min_allowed_equivalent_total_holding)
-                    # fees bring back the order delta into the expected portfolio delta window
-                    < abs(order_asset_delta + possible_fees_asset_deltas[asset_name])
-                    < abs(max_allowed_equivalent_total_holding)
+                    any(
+                        abs(min_allowed_equivalent_total_holding)
+                        # fees bring back the order delta into the expected portfolio delta window
+                        < abs(order_asset_delta + possible_fee)
+                        < abs(max_allowed_equivalent_total_holding)
+                        for possible_fee in (
+                            # try with smaller fees in case user is paying less fees (when having large volume)
+                            # test from 10% up to 100% fees
+                            possible_fees_asset_deltas[asset_name] * decimal.Decimal(multiplier / 10)
+                            for multiplier in range(1, 11)
+                        )
+                    )
                 )
             ):
                 orders_linked_deltas[asset_name] = holdings_delta
@@ -674,6 +682,7 @@ def get_assets_delta_from_orders(orders: list[order_import.Order]) -> (
     asset_deltas = {}
     expected_fee_related_deltas = {}
     possible_fee_related_deltas = {}
+    exchange_local_fees_currency_price = _get_exchange_local_fees_currency_price(orders)
     for order in orders:
         base, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
         # order "expected" related deltas
@@ -695,9 +704,11 @@ def get_assets_delta_from_orders(orders: list[order_import.Order]) -> (
                 asset_deltas[unit_and_amount[0]] += unit_and_amount[1] * multiplier
         # order "probable" related deltas (account for worse case fees)
         expected_forecasted_fees = order.get_computed_fee(use_origin_quantity_and_price=True)
-        possible_forecasted_fees = _get_other_asset_forecasted_fees(order, expected_forecasted_fees)
-        for fee_asset in (base, quote):
-            for fee in (expected_forecasted_fees, possible_forecasted_fees):
+        possible_forecasted_fees = _get_other_asset_forecasted_fees(
+            order, expected_forecasted_fees, exchange_local_fees_currency_price
+        )
+        for fee_asset in (base, quote) + tuple(exchange_local_fees_currency_price):
+            for fee in (expected_forecasted_fees, ) + possible_forecasted_fees:
                 is_expected_fee = fee is expected_forecasted_fees
                 if asset_amount := order_util.get_fees_for_currency(fee, fee_asset):
                     for delta_counter in (expected_fee_related_deltas, possible_fee_related_deltas):
@@ -710,13 +721,70 @@ def get_assets_delta_from_orders(orders: list[order_import.Order]) -> (
                             delta_counter[fee_asset] += -asset_amount
     return asset_deltas, expected_fee_related_deltas, possible_fee_related_deltas
 
-def _get_other_asset_forecasted_fees(order: order_import.Order, forecasted_fees: dict) -> dict:
+def _get_other_asset_forecasted_fees(
+    order: order_import.Order, forecasted_fees: dict, 
+    exchange_local_fees_currency_price: dict[str, dict[str, decimal.Decimal]]
+) -> tuple[dict]:
     base, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
     other_fee = copy.deepcopy(forecasted_fees)
+    base_local_fee = None
+    quote_local_fee = None
     if base_fee := order_util.get_fees_for_currency(forecasted_fees, base):
+        fee_cost = base_fee * order.origin_price
         other_fee[enums.FeePropertyColumns.CURRENCY.value] = quote
-        other_fee[enums.FeePropertyColumns.COST.value] = base_fee * order.origin_price
+        other_fee[enums.FeePropertyColumns.COST.value] = fee_cost
+        if base not in exchange_local_fees_currency_price and quote not in exchange_local_fees_currency_price:
+            for fee_currency, fee_price_by_symbol in exchange_local_fees_currency_price.items():
+                for fee_symbol, fee_price in fee_price_by_symbol.items():
+                    parsed_fee_symbol = symbol_util.parse_symbol(fee_symbol)
+                    # shared base or quote ? divive, multiply otherwise
+                    if parsed_fee_symbol.base == base or parsed_fee_symbol.quote == quote:
+                        base_local_fee = {
+                            enums.FeePropertyColumns.CURRENCY.value: fee_currency,
+                            enums.FeePropertyColumns.COST.value: fee_cost / fee_price
+                        }
+                    elif parsed_fee_symbol.base == quote or parsed_fee_symbol.quote == base:
+                        base_local_fee = {
+                            enums.FeePropertyColumns.CURRENCY.value: fee_currency,
+                            enums.FeePropertyColumns.COST.value: fee_cost * fee_price
+                        }
     elif quote_fee := order_util.get_fees_for_currency(forecasted_fees, quote):
+        fee_cost = quote_fee / order.origin_price
         other_fee[enums.FeePropertyColumns.CURRENCY.value] = base
-        other_fee[enums.FeePropertyColumns.COST.value] = quote_fee / order.origin_price
-    return other_fee
+        other_fee[enums.FeePropertyColumns.COST.value] = fee_cost
+        if base not in exchange_local_fees_currency_price and quote not in exchange_local_fees_currency_price:
+            for fee_currency, fee_price_by_symbol in exchange_local_fees_currency_price.items():
+                for fee_symbol, fee_price in fee_price_by_symbol.items():
+                    parsed_fee_symbol = symbol_util.parse_symbol(fee_symbol)
+                    # shared base or quote ? divive, multiply otherwise
+                    if parsed_fee_symbol.base == base or parsed_fee_symbol.quote == quote:
+                        quote_local_fee = {
+                            enums.FeePropertyColumns.CURRENCY.value: fee_currency,
+                            enums.FeePropertyColumns.COST.value: fee_cost / fee_price
+                        }
+                    elif parsed_fee_symbol.base == quote or parsed_fee_symbol.quote == base:
+                        quote_local_fee = {
+                            enums.FeePropertyColumns.CURRENCY.value: fee_currency,
+                            enums.FeePropertyColumns.COST.value: fee_cost * fee_price
+                        }
+    return tuple(
+        fee
+        for fee in (other_fee, base_local_fee, quote_local_fee)
+        if fee is not None
+    )
+
+
+def _get_exchange_local_fees_currency_price(orders: list[order_import.Order]) -> dict[str, dict[str, decimal.Decimal]]:
+    exchange_local_fees_currency_price = {}
+    # use given orders to get the price of the potential local fees currencies
+    # if an order trades this currency, then we can use its price to get the price of the currency
+    for order in orders:
+        for local_fees_currency in order.trader.exchange_manager.exchange.LOCAL_FEES_CURRENCIES:
+            if local_fees_currency not in exchange_local_fees_currency_price:
+                exchange_local_fees_currency_price[local_fees_currency] = {}
+            if (
+                local_fees_currency in symbol_util.parse_symbol(order.symbol).base_and_quote() 
+                and order.symbol not in exchange_local_fees_currency_price[local_fees_currency]
+            ):
+                exchange_local_fees_currency_price[local_fees_currency][order.symbol] = order.origin_price
+    return exchange_local_fees_currency_price

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/personal_data/trades/trade_factory.py

@@ -21,13 +21,9 @@ import octobot_trading.constants as constants
 
 
 def create_trade_instance_from_raw(trader, raw_trade):
-    try:
-        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)
-    except KeyError:
-        # Funding trade candidate
-        return None
+    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):

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/personal_data/trades/trades_manager.py

@@ -52,12 +52,17 @@ class TradesManager(util.Initializable):
 
     def upsert_trade(self, trade_id: str, raw_trade: dict) -> bool:
         if trade_id not in self.trades:
-            created_trade = personal_data.create_trade_instance_from_raw(self.trader, raw_trade)
-            if created_trade:
+            try:
+                created_trade = personal_data.create_trade_instance_from_raw(self.trader, raw_trade)
                 if trade_id in self.trades:
                     self.logger.debug(f"Replacement of an existing trade: {self.trades[trade_id].to_dict()} "
-                                      f"by {created_trade.to_dict()} on id: {trade_id}")
+                                    f"by {created_trade.to_dict()} on id: {trade_id}")
                 return self._add_trade_if_relevant(trade_id, created_trade)
+            except Exception as err:
+                message = f"Unexpected error when parsing [{self.trader.exchange_manager.exchange_name}] trade"
+                # don't spam with errors, only log warnings
+                self.logger.warning(message)
+                self.logger.exception(err, False, message)
         return False
 
     def upsert_trade_instance(self, trade):

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -286,10 +286,18 @@ async def get_cancelled_orders(
 )
 async def _get_trades(exchange_manager, symbol: str, trades: list):
     row_trades = await exchange_manager.exchange.get_my_recent_trades(symbol=symbol)
-    trades.extend(
-        personal_data.create_trade_instance_from_raw(exchange_manager.trader, raw_trade).to_dict()
-        for raw_trade in row_trades
-    )
+    for raw_trade in row_trades:
+        try:
+            trades.append(
+                personal_data.create_trade_instance_from_raw(exchange_manager.trader, raw_trade).to_dict()
+            )
+        except Exception as err:
+            logging.get_logger("get_trades").exception(
+                err,
+                True,
+                f"Unexpected error when parsing [{exchange_manager.exchange_name}] trade "
+                f"({err} {err.__class__.__name__}), trade: {raw_trade}. Ignored trade."
+            )
 
 
 async def get_trades(
@@ -400,10 +408,19 @@ async def get_positions(
     raw_positions = await exchange_manager.exchange.get_positions(symbols=symbols)
     # initialize relevant contracts first as they might be waited for
     trading_exchange_data.update_contracts_from_positions(exchange_manager, raw_positions)
-    dict_positions = [
-        personal_data.create_position_instance_from_raw(
-            exchange_manager.trader, raw_position
-        ).to_dict()
-        for raw_position in raw_positions
-    ]
+    dict_positions = []
+    for raw_position in raw_positions:
+        try:
+            dict_positions.append(
+                personal_data.create_position_instance_from_raw(
+                    exchange_manager.trader, raw_position
+                ).to_dict()
+            )
+        except Exception as err:
+            logging.get_logger("get_positions").exception(
+                err,
+                True,
+                f"Unexpected error when parsing [{exchange_manager.exchange_name}] position"
+                f"({err}. {err.__class__.__name__}), position: {raw_position}. Ignored position."
+            )
     return dict_positions

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/tests/personal_data/portfolios/test_portfolio_util.py

@@ -478,8 +478,9 @@ def test_get_portfolio_filled_orders_deltas_considering_fees():
         pre_trade_content = _content({"BTC": 0.00226262681, "USDT": 4376.532183487584})
         post_trade_content = _content({"BTC": 0.00227318792 - BTC_fees, "USDT": 4375.22614367084})
         filled_orders = [
-            _order("BTC/USDT", 0.00108723, 111.778333746, "sell", {"USDT": 0.111778333746}),
-            _order("BTC/USDT", 0.00109889, 112.972595229, "buy", {"USDT": 0.111778333746}), # expects USDT as fees but was actually BTC
+            # note: include ignored local exchange fees
+            _order("BTC/USDT", 0.00108723, 111.778333746, "sell", {"USDT": 0.111778333746}, local_fees_currencies=["BNB"]),
+            _order("BTC/USDT", 0.00109889, 112.972595229, "buy", {"USDT": 0.111778333746}, local_fees_currencies=["BNB"]), # expects USDT as fees but was actually BTC
         ]
         assert personal_data.get_portfolio_filled_orders_deltas(
             pre_trade_content, post_trade_content, filled_orders
@@ -494,8 +495,9 @@ def test_get_portfolio_filled_orders_deltas_considering_fees():
         pre_trade_content = _content({"BTC": 0.00226262681, "USDT": 4376.532183487584})
         post_trade_content = _content({"BTC": 0.00227318792, "USDT": 4375.22614367084})
         filled_orders = [
-            _order("BTC/USDT", 0.00108723, 111.778333746, "sell", {"USDT": 0.111778333746}), # expects USDT as fees but was actually something else (like BNB)
-            _order("BTC/USDT", 0.00109779111, 112.972595229, "buy", {"USDT": 0.111778333746}), # expects USDT as fees but was actually something else (like BNB)
+            # note: include ignored local exchange fees
+            _order("BTC/USDT", 0.00108723, 111.778333746, "sell", {"USDT": 0.111778333746}, local_fees_currencies=["BNB"]), # expects USDT as fees but was actually something else (like BNB)
+            _order("BTC/USDT", 0.00109779111, 112.972595229, "buy", {"USDT": 0.111778333746}, local_fees_currencies=["KCS"]), # expects USDT as fees but was actually something else (like BNB)
         ]
         assert personal_data.get_portfolio_filled_orders_deltas(
             pre_trade_content, post_trade_content, filled_orders
@@ -511,8 +513,9 @@ def test_get_portfolio_filled_orders_deltas_considering_fees():
         pre_trade_content = _content({"MANA": 103.42087452540375, "USDC": actual_fees})
         post_trade_content = _content({"MANA": 72.65087452540375, "USDC": 0.0827944124999931})
         filled_orders = [
-            _order("MANA/USDC", 103.05, 37.005255, "sell", {"USDC": actual_fees * 2}), # expects 1.2% fees
-            _order("MANA/USDC", 72.28, 36.644921175, "buy", {"USDC": actual_fees * 2}),    # expects 1.2% fees
+            # note: include unused local exchange fees
+            _order("MANA/USDC", 103.05, 37.005255, "sell", {"USDC": actual_fees * 2}, local_fees_currencies=["BNB"]), # expects 1.2% fees
+            _order("MANA/USDC", 72.28, 36.644921175, "buy", {"USDC": actual_fees * 2}, local_fees_currencies=["BNB"]),    # expects 1.2% fees
         ]
         assert personal_data.get_portfolio_filled_orders_deltas(
             pre_trade_content, post_trade_content, filled_orders
@@ -524,6 +527,92 @@ def test_get_portfolio_filled_orders_deltas_considering_fees():
         error_log.assert_not_called()
 
 
+def test_get_portfolio_filled_orders_deltas_considering_local_exchange_fees():
+    error_log = mock.Mock()
+    with mock.patch.object(octobot_commons.logging, "get_logger", mock.Mock(return_value=mock.Mock(error=error_log))):
+        # with high fees paid in BNB (real world example)
+        # 1. with buy order
+        pre_trade_content = _content({"BTC": 0.000164, "BNB": 0.3549429, "USDT": 745.08144})
+        post_trade_content = _content({
+            "BTC": 0.006404, # 0.000164+0.00016*39
+            "BNB": 0.37513215, # should be 0.3549429+0.025 = 0.3799429 BUT all order fees were actually paid in BNB for a total of 0.00481075 BNB (which is large (20%) compared to the 0.025 BNB that we just bought)
+            "USDT": 10
+        })
+        filled_orders = [
+            # expected fees are in the wrong currency (actual fees were paid in BNB)
+            _order("BNB/USDT", 0.025, 753.92*0.025, "buy", {"BNB": 0.00015}, local_fees_currencies=["BNB"]),
+            _order("BTC/USDT", 0.00016*39, 114781.0*0.00016*39, "buy", {"BTC": 9.6E-7*39}, local_fees_currencies=["BNB"]),   # *39 to simulate 39 total other orders
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders
+        ) == (
+            # all deltas are accepted, BNB 20% delta from order is accepted from BNB fees
+            _content({"BTC": 0.00624, "BNB": 0.02018925, "USDT": -735.08144}),
+            {},
+        )
+        error_log.assert_not_called()
+
+        pre_trade_content = _content({"BTC": 0.000164, "BNB": 0.3549429, "USDT": 745.08144})
+        post_trade_content = _content({
+            "BTC": 0.006404, # 0.000164+0.00016*39
+            "BNB": 0.32513215, # should be 0.3549429-0.025 = 0.3299429 BUT all order fees were actually paid in BNB for a total of 0.00481075 BNB (which is large (20%) compared to the 0.025 BNB that we just bought)
+            "USDT": 47.696  # 745.08144-114781.0*0.00016*39+18.848
+        })
+        filled_orders = [
+            # expected fees are in the wrong currency (actual fees were paid in BNB)
+            _order("USDT/BNB", 18.848, 18.848/753.92, "buy", {"BNB": 0.00015}, local_fees_currencies=["BNB"]),
+            _order("BTC/USDT", 0.00016*39, 114781.0*0.00016*39, "buy", {"BTC": 9.6E-7*39}, local_fees_currencies=["BNB"]),   # *39 to simulate 39 total other orders
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders
+        ) == (
+            # all deltas are accepted, BNB 20% delta from order is accepted from BNB fees
+            _content({"BTC": 0.00624, "BNB": -0.025, "USDT": -697.38544}),
+            {},
+        )
+        error_log.assert_not_called()
+
+        # 2. with sell order
+        pre_trade_content = _content({"BTC": 0.000164, "BNB": 0.3549429, "USDT": 745.08144})
+        post_trade_content = _content({
+            "BTC": 0.006404, # 0.000164+0.00016*39
+            "BNB": 0.32513215, # should be 0.3549429-0.025 = 0.3299429 BUT all order fees were actually paid in BNB for a total of 0.00481075 BNB (which is large (20%) compared to the 0.025 BNB that we just bought)
+            "USDT": 47.696  # 745.08144-114781.0*0.00016*39+18.848
+        })
+        filled_orders = [
+            # expected fees are in the wrong currency (actual fees were paid in BNB)
+            _order("BNB/USDT", 0.025, 753.92*0.025, "sell", {"BNB": 0.00015}, local_fees_currencies=["BNB"]),
+            _order("BTC/USDT", 0.00016*39, 114781.0*0.00016*39, "buy", {"BTC": 9.6E-7*39}, local_fees_currencies=["BNB"]),   # *39 to simulate 39 total other orders
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders
+        ) == (
+            # all deltas are accepted, BNB 20% delta from order is accepted from BNB fees
+            _content({"BTC": 0.00624, "BNB": -0.025, "USDT": -697.38544}),
+            {},
+        )
+        error_log.assert_not_called()
+        pre_trade_content = _content({"BTC": 0.000164, "BNB": 0.3549429, "USDT": 745.08144})
+        post_trade_content = _content({
+            "BTC": 0.006404, # 0.000164+0.00016*39
+            "BNB": 0.37513215, # should be 0.3549429+0.025 = 0.3799429 BUT all order fees were actually paid in BNB for a total of 0.00481075 BNB (which is large (20%) compared to the 0.025 BNB that we just bought)
+            "USDT": 10
+        })
+        filled_orders = [
+            # expected fees are in the wrong currency (actual fees were paid in BNB)
+            _order("USDT/BNB", 18.848, 18.848/753.92, "sell", {"BNB": 0.00015}, local_fees_currencies=["BNB"]),  # reversed symbol
+            _order("BTC/USDT", 0.00016*39, 114781.0*0.00016*39, "buy", {"BTC": 9.6E-7*39}, local_fees_currencies=["BNB"]),   # *39 to simulate 39 total other orders
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders
+        ) == (
+            # all deltas are accepted, BNB 20% delta from order is accepted from BNB fees
+            _content({"BTC": 0.00624, "BNB": 0.02018925, "USDT": -735.08144}),
+            {},
+        )
+        error_log.assert_not_called()
+
+
 def test_get_accepted_missed_deltas():
     # with no delta
     post_trade_content = _content({"XRP": 40, "USDT": 129.2474232})
@@ -819,8 +908,8 @@ def _missing_funds(funds: dict[str, float]) -> dict[str, decimal.Decimal]:
         for key, val in funds.items()
     }
 
-def _order(symbol: str, quantity: float, cost: float, side: str, fee: dict = None) -> personal_data.Order:
-    trader = mock.Mock(exchange_manager=mock.Mock())
+def _order(symbol: str, quantity: float, cost: float, side: str, fee: dict = None, local_fees_currencies: list[str] = []) -> personal_data.Order:
+    trader = mock.Mock(exchange_manager=mock.Mock(exchange=mock.Mock(LOCAL_FEES_CURRENCIES=local_fees_currencies)))
     order = personal_data.Order(trader)
     order.symbol = symbol
     order.origin_quantity = decimal.Decimal(str(quantity))

{OctoBot-Trading-2.4.202 → OctoBot-Trading-2.4.204}/tests/personal_data/trades/test_trade_factory.py

@@ -58,6 +58,9 @@ class TestTradeFactory:
     async def test_create_trade_instance_from_raw(self):
         _, exchange_manager, trader = await self.init_default()
 
+        with pytest.raises(KeyError):
+            create_trade_instance_from_raw(trader, {})
+
         raw_trade = json.loads(
             """
             {