OctoBot-Trading 2.4.203__tar.gz → 2.4.205__tar.gz

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/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.205] - 2025-08-07
+### Updated
+[SubPortfolio] add filled/cancelled orders inferring enging
+
+## [2.4.204] - 2025-08-04
+### Updated
+[SubPortfolio] handle local exchange symbols fees
+
 ## [2.4.203] - 2025-08-03
 ### Updated
 [Trades] log parsing error

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.203
+Version: 2.4.205
 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.203](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.205](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.203 → OctoBot-Trading-2.4.205}/OctoBot_Trading.egg-info/SOURCES.txt

@@ -222,6 +222,7 @@ octobot_trading/personal_data/portfolios/portfolio_manager.py
 octobot_trading/personal_data/portfolios/portfolio_profitability.py
 octobot_trading/personal_data/portfolios/portfolio_util.py
 octobot_trading/personal_data/portfolios/portfolio_value_holder.py
+octobot_trading/personal_data/portfolios/resolved_orders_portfolio_delta.py
 octobot_trading/personal_data/portfolios/sub_portfolio.py
 octobot_trading/personal_data/portfolios/sub_portfolio_data.py
 octobot_trading/personal_data/portfolios/value_converter.py

{OctoBot-Trading-2.4.203/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.205}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.203
+Version: 2.4.205
 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.203](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.205](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.203 → OctoBot-Trading-2.4.205}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.203](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.205](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.203 → OctoBot-Trading-2.4.205}/octobot_trading/__init__.py

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

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/octobot_trading/api/portfolio.py

@@ -125,22 +125,19 @@ def is_usd_like_coin(coin) -> bool:
 def resolve_sub_portfolios(
     master_portfolio: personal_data.SubPortfolioData,
     sub_portfolios: list[personal_data.SubPortfolioData],
-    allowed_filling_assets: list[str],
-    forbidden_filling_assets: list[str],
     market_prices: dict[str, float],
 ) -> (personal_data.SubPortfolioData, list[personal_data.SubPortfolioData]):
-    return personal_data.resolve_sub_portfolios(
-        master_portfolio, sub_portfolios, allowed_filling_assets, forbidden_filling_assets, market_prices
-    )
+    return personal_data.resolve_sub_portfolios(master_portfolio, sub_portfolios, market_prices)
 
 
 def get_portfolio_filled_orders_deltas(
     previous_portfolio_content: dict[str, dict[str, decimal.Decimal]],
     updated_portfolio_content: dict[str, dict[str, decimal.Decimal]],
-    filled_orders: list[personal_data.Order]
-) -> (dict[str, dict[str, decimal.Decimal]], dict[str, dict[str, decimal.Decimal]]):
+    filled_orders: list[personal_data.Order],
+    unknown_filled_or_cancelled_orders: list[personal_data.Order]
+) -> personal_data.ResolvedOrdersPortoflioDelta:
     return personal_data.get_portfolio_filled_orders_deltas(
-        previous_portfolio_content, updated_portfolio_content, filled_orders
+        previous_portfolio_content, updated_portfolio_content, filled_orders, unknown_filled_or_cancelled_orders
     )
 
 

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -25,7 +25,6 @@ import binascii
 import copy
 
 import octobot_commons.enums
-import octobot_commons.logging
 import octobot_commons.symbols as commons_symbols
 import octobot_commons.html_util as html_util
 

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/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.203 → OctoBot-Trading-2.4.205}/octobot_trading/personal_data/__init__.py

@@ -177,6 +177,7 @@ from octobot_trading.personal_data.portfolios import (
     HistoricalAssetValue,
     HistoricalPortfolioValueManager,
     SubPortfolioData,
+    ResolvedOrdersPortoflioDelta,
 )
 from octobot_trading.personal_data import positions
 from octobot_trading.personal_data.positions import (
@@ -474,4 +475,5 @@ __all__ = [
     "create_fee_transaction",
     "create_transfer_transaction",
     "SubPortfolioData",
+    "ResolvedOrdersPortoflioDelta",
 ]

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/octobot_trading/personal_data/orders/order.py

@@ -1142,7 +1142,7 @@ class Order(util.Initializable):
         return self.trader is not None
 
 
-def parse_order_type(raw_order):
+def parse_order_type(raw_order) -> (enums.TradeOrderSide, enums.TraderOrderType):
     try:
         side: enums.TradeOrderSide = enums.TradeOrderSide(raw_order[enums.ExchangeConstantsOrderColumns.SIDE.value])
         order_type: enums.TradeOrderType = enums.TradeOrderType.UNKNOWN

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/octobot_trading/personal_data/portfolios/__init__.py

@@ -44,7 +44,7 @@ from octobot_trading.personal_data.portfolios import types
 from octobot_trading.personal_data.portfolios import portfolio_util
 from octobot_trading.personal_data.portfolios import history
 from octobot_trading.personal_data.portfolios import sub_portfolio_data
-
+from octobot_trading.personal_data.portfolios import resolved_orders_portfolio_delta
 
 from octobot_trading.personal_data.portfolios.portfolio_factory import (
     create_portfolio_from_exchange_manager,
@@ -97,7 +97,10 @@ from octobot_trading.personal_data.portfolios.history import (
 from octobot_trading.personal_data.portfolios.sub_portfolio_data import (
     SubPortfolioData,
 )
-
+from octobot_trading.personal_data.portfolios.resolved_orders_portfolio_delta import (
+    ResolvedOrdersPortoflioDelta,
+)
+    
 __all__ = [
     "BalanceUpdaterSimulator",
     "BalanceProfitabilityUpdaterSimulator",
@@ -139,4 +142,5 @@ __all__ = [
     "HistoricalAssetValue",
     "HistoricalPortfolioValueManager",
     "SubPortfolioData",
+    "ResolvedOrdersPortoflioDelta",
 ]

{OctoBot-Trading-2.4.203 → OctoBot-Trading-2.4.205}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -16,12 +16,14 @@
 import copy
 import decimal
 import typing
+import itertools
 
 import octobot_trading.personal_data.portfolios.asset as asset
 import octobot_trading.personal_data.portfolios.assets
 import octobot_trading.personal_data.orders.order as order_import
 import octobot_trading.personal_data.orders.order_util as order_util
 import octobot_trading.personal_data.portfolios.sub_portfolio_data as sub_portfolio_data
+import octobot_trading.personal_data.portfolios.resolved_orders_portfolio_delta as resolved_orders_portfolio_delta
 import octobot_trading.constants as constants
 import octobot_trading.enums as enums
 import octobot_trading.errors as errors
@@ -258,16 +260,12 @@ def get_asset_price_from_converter_or_tickers(
 def resolve_sub_portfolios(
     master_portfolio: sub_portfolio_data.SubPortfolioData,
     sub_portfolios: list[sub_portfolio_data.SubPortfolioData],
-    allowed_filling_assets: list[str],
-    forbidden_filling_assets: list[str],
     market_prices: dict[str, float],
 ) -> (sub_portfolio_data.SubPortfolioData, list[sub_portfolio_data.SubPortfolioData]):
     resolved_portfolios = []
     remaining_master_portfolio = copy.deepcopy(master_portfolio)
     for sub_portfolio in sorted(sub_portfolios, key=lambda x: x.priority_key):
-        resolved_portfolio = _resolve_sub_portfolio(
-            remaining_master_portfolio, sub_portfolio, allowed_filling_assets, forbidden_filling_assets, market_prices
-        )
+        resolved_portfolio = _resolve_sub_portfolio(remaining_master_portfolio, sub_portfolio, market_prices)
         resolved_portfolios.append(resolved_portfolio)
     return remaining_master_portfolio, resolved_portfolios
 
@@ -275,8 +273,6 @@ def resolve_sub_portfolios(
 def _resolve_sub_portfolio(
     remaining_master_portfolio: sub_portfolio_data.SubPortfolioData,
     sub_portfolio: sub_portfolio_data.SubPortfolioData,
-    allowed_filling_assets: list[str],
-    forbidden_filling_assets: list[str],
     market_prices: dict[str, float],
 ) -> sub_portfolio_data.SubPortfolioData:
     resolved_content = {}
@@ -287,14 +283,14 @@ def _resolve_sub_portfolio(
     for asset_name, holdings in forecasted_sub_portfolio_content.items():
         missing_amount_in_asset = _resolve_sub_portfolio_asset(
             asset_name, holdings, remaining_master_portfolio, resolved_content,
-            sub_portfolio.locked_funds_by_asset.get(asset_name, constants.ZERO), forbidden_filling_assets
+            sub_portfolio.locked_funds_by_asset.get(asset_name, constants.ZERO), sub_portfolio.forbidden_filling_assets
         )
         if missing_amount_in_asset > constants.ZERO:
             missing_amount_by_asset[asset_name] = missing_amount_in_asset
     # now that assets have been allocated, try to compensate missing assets
     for asset_name, missing_amount_in_asset in missing_amount_by_asset.items():
         _fill_missing_assets_from_allowed_filling_assets(
-            asset_name, allowed_filling_assets, market_prices,
+            asset_name, sub_portfolio.allowed_filling_assets, market_prices,
             remaining_master_portfolio, missing_amount_in_asset,
             resolved_content, funds_deltas, missing_funds
         )
@@ -305,8 +301,8 @@ def _resolve_sub_portfolio(
         sub_portfolio.priority_key,
         resolved_content,
         sub_portfolio.unit,
-        funds_deltas,
-        missing_funds,
+        funds_deltas=funds_deltas,
+        missing_funds=missing_funds,
     )
 
 
@@ -424,6 +420,7 @@ def _fill_missing_assets_from_allowed_filling_assets(
                     commons_constants.PORTFOLIO_TOTAL: funds_to_add_in_filling_asset,
                     commons_constants.PORTFOLIO_AVAILABLE: funds_to_add_in_filling_asset,
                 }
+            # register filling assets in funds_deltas
             if filling_asset in funds_deltas:
                 funds_deltas[filling_asset][commons_constants.PORTFOLIO_TOTAL] += funds_to_add_in_filling_asset
                 funds_deltas[filling_asset][commons_constants.PORTFOLIO_AVAILABLE] += funds_to_add_in_filling_asset
@@ -544,16 +541,147 @@ def get_missing_master_portfolio_values_update(
 def get_portfolio_filled_orders_deltas(
     previous_portfolio_content: dict[str, dict[str, decimal.Decimal]],
     updated_portfolio_content: dict[str, dict[str, decimal.Decimal]],
-    filled_orders: list[order_import.Order]
-) -> (dict[str, dict[str, decimal.Decimal]], dict[str, dict[str, decimal.Decimal]]):
-    orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas = get_assets_delta_from_orders(filled_orders)
+    filled_orders: list[order_import.Order],
+    unknown_filled_or_cancelled_orders: list[order_import.Order]
+) -> resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta:
     portfolios_asset_deltas = _get_assets_delta_from_portfolio(previous_portfolio_content, updated_portfolio_content)
-    # return portfolio asset deltas that can approximately be explained by given orders
+    if unknown_filled_or_cancelled_orders:
+        return _compute_most_probable_assets_deltas_from_orders_considering_unknown_orders(
+            filled_orders, portfolios_asset_deltas, unknown_filled_or_cancelled_orders
+        )
+    else:
+        orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas = get_assets_delta_from_orders(filled_orders)
+        return compute_assets_deltas_from_orders(
+            orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas, 
+            portfolios_asset_deltas, allow_portfolio_delta_shrinking=True
+        )
+
+
+def _reverse_portfolio_deltas(
+    portfolios_asset_deltas: dict[str, dict[str, decimal.Decimal]],
+) -> dict[str, dict[str, decimal.Decimal]]:
+    return {
+        asset_name: {
+            key: -delta_values[key] for key in delta_values
+        }
+        for asset_name, delta_values in portfolios_asset_deltas.items()
+    }
+
+
+def _compute_most_probable_assets_deltas_from_orders_considering_unknown_orders(
+    filled_orders: list[order_import.Order],
+    portfolios_asset_deltas: dict[str, dict[str, decimal.Decimal]],
+    unknown_filled_or_cancelled_orders: list[order_import.Order]
+) -> resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta:
+    """
+    Returns the most probable deltas which are the ones that can be best explained by given orders
+    """
+
+    if filled_orders:
+        orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas = get_assets_delta_from_orders(
+            filled_orders
+        )
+        known_filled_orders_resolved_delta = compute_assets_deltas_from_orders(
+            orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas, 
+            portfolios_asset_deltas, 
+            allow_portfolio_delta_shrinking=False, 
+            allow_mixed_sign_delta=True,
+            register_missed_partial_delta_as_ignored=True, 
+            ignore_order_unrelated_deltas=False,
+            ignore_order_extra_deltas=False,
+        )
+    else:
+        known_filled_orders_resolved_delta = resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta()
+    # init with all cancelled orders and explained+unexplained portfolio deltas from known filled orders
+    best_inferred_resolved_delta = resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta(
+        inferred_cancelled_orders=unknown_filled_or_cancelled_orders,
+    ).merge_order_deltas(known_filled_orders_resolved_delta, portfolios_asset_deltas)
+    post_filled_orders_portfolio_asset_deltas = resolved_orders_portfolio_delta.filter_empty_deltas(
+        sub_portfolio_data.get_content_after_deltas(
+            portfolios_asset_deltas, _reverse_portfolio_deltas(
+                best_inferred_resolved_delta.explained_orders_deltas
+            ), apply_available_deltas=True
+        )
+    ) 
+    # start at 1 to avoid considering no filled orders (already considered in best_inferred_resolved_delta)
+    for orders_to_fill_count in range(1, len(unknown_filled_or_cancelled_orders) + 1):
+        for filled_orders_combination in itertools.combinations(unknown_filled_or_cancelled_orders, orders_to_fill_count):
+            potential_filled_orders_combination = list(filled_orders_combination)
+            orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas = get_assets_delta_from_orders(
+                potential_filled_orders_combination
+            )
+            if any(
+                asset_name not in post_filled_orders_portfolio_asset_deltas   # use post_filled_orders_portfolio_asset_deltas?
+                for asset_name in orders_asset_deltas
+            ):
+                # at least one of the candidate filled orders is not related to portfolio delta: skip this combination
+                continue
+            inferred_resolved_delta_candidate = compute_assets_deltas_from_orders(
+                orders_asset_deltas, expected_fee_related_deltas, possible_fees_asset_deltas, 
+                post_filled_orders_portfolio_asset_deltas, 
+                allow_portfolio_delta_shrinking=False, 
+                register_missed_partial_delta_as_ignored=True, 
+                ignore_order_unrelated_deltas=False,
+                ignore_order_extra_deltas=True,
+            )
+            if not inferred_resolved_delta_candidate.adds_explanations():
+                # no added explanations: skip this combination
+                continue
+            merged_inferred_resolved_delta_candidate = inferred_resolved_delta_candidate.merge_order_deltas(
+                known_filled_orders_resolved_delta, portfolios_asset_deltas
+            )
+            merged_inferred_resolved_delta_candidate.inferred_filled_orders = potential_filled_orders_combination
+            merged_inferred_resolved_delta_candidate.inferred_cancelled_orders = [
+                order for order in unknown_filled_or_cancelled_orders if order not in potential_filled_orders_combination
+            ]
+            try:
+                if merged_inferred_resolved_delta_candidate.is_fully_explained():
+                    return _get_cleared_inferred_resolved_delta(
+                        merged_inferred_resolved_delta_candidate, portfolios_asset_deltas
+                    )
+                elif merged_inferred_resolved_delta_candidate.is_more_probable_than(best_inferred_resolved_delta):
+                    best_inferred_resolved_delta = merged_inferred_resolved_delta_candidate
+            except KeyError as err:
+                # should not happen, catch it to avoid raising it if it does
+                commons_logging.get_logger(__name__).error(
+                    f"Unexpected error when computing most probable assets deltas from orders: {err}"
+                )
+    return _get_cleared_inferred_resolved_delta(best_inferred_resolved_delta, portfolios_asset_deltas)
+
+
+def _get_cleared_inferred_resolved_delta(
+    resolved_delta: resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta,
+    portfolios_asset_deltas: dict[str, dict[str, decimal.Decimal]],
+) -> resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta:
+    # clear partial deltas as they should not be considered real deltas (they are due to other "unknown" orders)
+    resolved_delta.ensure_max_delta_and_clear_irrelevant_deltas(portfolios_asset_deltas)
+    return resolved_delta
+
+
+def compute_assets_deltas_from_orders(
+    orders_asset_deltas: dict[str, decimal.Decimal], 
+    expected_fee_related_deltas: dict[str, decimal.Decimal], 
+    possible_fees_asset_deltas: dict[str, decimal.Decimal],
+    portfolios_asset_deltas: dict[str, dict[str, decimal.Decimal]],
+    allow_portfolio_delta_shrinking: bool = True,
+    allow_mixed_sign_delta: bool = False,
+    register_missed_partial_delta_as_ignored: bool = False,
+    ignore_order_unrelated_deltas: bool = True,
+    ignore_order_extra_deltas: bool = False,
+) -> resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta:
+    """
+    returns portfolio asset deltas that can approximately be explained by given orders
+    """
     orders_linked_deltas = {}
     ignored_deltas = {}
     for asset_name, holdings_delta in portfolios_asset_deltas.items():
         if asset_name not in orders_asset_deltas:
-            # this delta is not due to these orders: skip it
+            if ignore_order_unrelated_deltas:
+                # this delta is not due to these orders: skip it
+                continue
+            else:
+                # this delta is not due to these orders: add it to ignored deltas
+                ignored_deltas[asset_name] = holdings_delta
             continue
         order_asset_delta = orders_asset_deltas[asset_name]
         holding_total = holdings_delta[commons_constants.PORTFOLIO_TOTAL]
@@ -569,7 +697,13 @@ def get_portfolio_filled_orders_deltas(
                 * min_allowed_equivalent_total_holding < 0
         ):
             # different sign: incompatible, this is unexpected
-            ignored_deltas[asset_name] = holdings_delta
+            if allow_mixed_sign_delta:
+                orders_linked_deltas[asset_name] = {
+                    key: order_asset_delta
+                    for key in holdings_delta
+                }
+            else:
+                ignored_deltas[asset_name] = holdings_delta
         elif (
             # approx same value
             abs(min_allowed_equivalent_total_holding)
@@ -609,10 +743,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
@@ -622,35 +764,58 @@ def get_portfolio_filled_orders_deltas(
                 # Add it to ignored_deltas
                 ignored_deltas[asset_name] = holdings_delta
         elif abs(min_allowed_equivalent_total_holding) > abs(order_asset_delta):
-            # too much in portfolio delta: only take what is linked to the orders deltas
-            # => updates both total and available
-            # Should very rarely happen as it might reduce the total portfolio if done when unecessary
-            commons_logging.get_logger(__name__).warning(
-                f"Too large portfolio {asset_name} delta: {holdings_delta}, reducing to order delta: {order_asset_delta}"
+            # too much in portfolio delta
+            if register_missed_partial_delta_as_ignored:
+                # Partial deltas: only take what is linked to the orders deltas
+                # => updates both total and available
+                orders_linked_deltas[asset_name] = {
+                    key: order_asset_delta
+                    for key in holdings_delta
+                }
+                # register extra delta as ignored
+                ignored_deltas[asset_name] = {
+                    key: pf_delta - order_asset_delta if abs(pf_delta - order_asset_delta) > constants.ZERO else constants.ZERO
+                    for key, pf_delta in holdings_delta.items()
+                }
+            elif allow_portfolio_delta_shrinking:
+                # Only take what is linked to the orders deltas and ignore extra delta values (shrink portfolio deltas)
+                # => updates both total and available
+                # Should very rarely happen as it might reduce the total portfolio if done when unecessary
+                commons_logging.get_logger(__name__).warning(
+                    f"Too large portfolio {asset_name} delta: {holdings_delta}, reducing to order delta: {order_asset_delta}"
+                )
+                orders_linked_deltas[asset_name] = {
+                    key: order_asset_delta
+                    for key in holdings_delta
+                }
+            else:
+                # can't be from those orders: ignore this delta
+                ignored_deltas[asset_name] = holdings_delta
+
+    if not ignore_order_extra_deltas:
+        # consider order deltas that are seen in portfolio deltas
+        for asset_name, order_delta in orders_asset_deltas.items():
+            can_have_no_delta = (
+                (order_delta == constants.ZERO)
+                or (order_delta + possible_fees_asset_deltas.get(asset_name, constants.ZERO)) == constants.ZERO
+                or (order_delta - possible_fees_asset_deltas.get(asset_name, constants.ZERO)) == constants.ZERO
             )
-            orders_linked_deltas[asset_name] = {
-                key: order_asset_delta
-                for key in holdings_delta
-            }
-    for asset_name, order_delta in orders_asset_deltas.items():
-        can_have_no_delta = (
-            (order_delta == constants.ZERO)
-            or (order_delta + possible_fees_asset_deltas.get(asset_name, constants.ZERO)) == constants.ZERO
-            or (order_delta - possible_fees_asset_deltas.get(asset_name, constants.ZERO)) == constants.ZERO
-        )
-        if asset_name not in portfolios_asset_deltas and not can_have_no_delta:
-            # asset not in portfolio delta, this is unexpected, register it in ignored deltas
-            ignored_deltas[asset_name] = {
-                commons_constants.PORTFOLIO_TOTAL: order_delta,
-                commons_constants.PORTFOLIO_AVAILABLE: order_delta
-            }
-    return orders_linked_deltas, ignored_deltas
+            if asset_name not in portfolios_asset_deltas and not can_have_no_delta:
+                # asset not in portfolio delta, this is unexpected, register it in ignored deltas
+                ignored_deltas[asset_name] = {
+                    commons_constants.PORTFOLIO_TOTAL: order_delta,
+                    commons_constants.PORTFOLIO_AVAILABLE: order_delta
+                }
+    return resolved_orders_portfolio_delta.ResolvedOrdersPortoflioDelta(
+        explained_orders_deltas=orders_linked_deltas,
+        unexplained_orders_deltas=ignored_deltas
+    )
 
 
 def _get_assets_delta_from_portfolio(
     previous_portfolio_content: dict,
     updated_portfolio_content: dict,
-) ->  dict[str, dict[str, decimal.Decimal]]:
+) -> dict[str, dict[str, decimal.Decimal]]:
     asset_deltas = {}
     for asset_name in set(previous_portfolio_content).union(updated_portfolio_content):
         if previous_portfolio_content.get(asset_name) != updated_portfolio_content.get(asset_name):
@@ -674,6 +839,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 +861,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 +878,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