OctoBot-Trading 2.4.207__tar.gz → 2.4.209__tar.gz

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/CHANGELOG.md

@@ -4,6 +4,15 @@ 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.209] - 2025-08-21
+### Updated
+[Portfolio] consider order fees in delta when from exchange
+[Orders] set order_exchange_id in from_dict factory when available
+
+## [2.4.208] - 2025-08-18
+### Updated
+[CCXT] update to 4.5.0
+
 ## [2.4.207] - 2025-08-16
 ### Updated
 [ExchangeData] add exchange_credential_id

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -353,6 +353,7 @@ tests/exchanges/connectors/__init__.py
 tests/exchanges/connectors/test_util.py
 tests/exchanges/connectors/ccxt/__init__.py
 tests/exchanges/connectors/ccxt/mock_exchanges_data.py
+tests/exchanges/connectors/ccxt/test_ccxt_client_util.py
 tests/exchanges/connectors/ccxt/test_ccxt_connector.py
 tests/exchanges/implementations/__init__.py
 tests/exchanges/implementations/test_default_rest_exchange.py

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/OctoBot_Trading.egg-info/requires.txt

@@ -4,7 +4,7 @@ Async-Channel<2.3,>=2.2
 OctoBot-Commons<1.10,>=1.9.64
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.35
-ccxt==4.4.85
+ccxt==4.5.0
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2

{OctoBot-Trading-2.4.207/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.209}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/octobot_trading/constants.py

@@ -113,7 +113,7 @@ NaN = decimal.Decimal("nan")
 
 # exchanges where test_get_historical_symbol_prices is successful can be listed here
 FULL_CANDLE_HISTORY_EXCHANGES = [
-    # "ascendex",   broken since ccxt==4.4.85
+    "ascendex",
     "binance",
     "bitfinex",
     "bitstamp",

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/octobot_trading/exchanges/config/proxy_config.py

@@ -22,12 +22,12 @@ import octobot_trading.constants
 class ProxyConfig:
     # REST proxy
     http_proxy: typing.Optional[str] = None
-    http_proxy_callback: typing.Optional[typing.Callable] = None
+    http_proxy_callback: typing.Optional[typing.Callable[[str, str, dict, typing.Any], typing.Optional[str]]] = None
     https_proxy: typing.Optional[str] = None
-    https_proxy_callback: typing.Optional[typing.Callable] = None
+    https_proxy_callback: typing.Optional[typing.Callable[[str, str, dict, typing.Any], typing.Optional[str]]] = None
     # Websocket proxy
     socks_proxy : typing.Optional[str] = None
-    socks_proxy_callback: typing.Optional[typing.Callable] = None
+    socks_proxy_callback: typing.Optional[typing.Callable[[str, str, dict, typing.Any], typing.Optional[str]]] = None
     # enable trust_env in exchange's aiohttp.ClientSession
     aiohttp_trust_env: bool = octobot_trading.constants.ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV
     # if set, will be called when exchange stops
@@ -37,9 +37,6 @@ class ProxyConfig:
     get_proxy_url: typing.Optional[typing.Callable[[], str]] = None
     # the host of this proxy, used to identify proxy connexion errors
     proxy_host: str = "DEFAULT PROXY HOST"
-    # if DNS cache should be disabled with this proxy config. Warning: in this case, DNS cache will be
-    # completely disabled for this exchange
-    disable_dns_cache: bool = False
 
     @classmethod
     def default_env_var_config(cls):

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -328,7 +328,6 @@ def _use_proxy_if_necessary(client, proxy_config: proxy_config_import.ProxyConfi
                     # extra args copied from self.open()
                     ssl=client.ssl_context,
                     loop=client.asyncio_loop,
-                    use_dns_cache=not proxy_config.disable_dns_cache,
                     enable_cleanup_closed=True
                 )
                 client.socks_proxy_sessions[proxy_url] = aiohttp.ClientSession(
@@ -342,21 +341,6 @@ def _use_proxy_if_necessary(client, proxy_config: proxy_config_import.ProxyConfi
                 raise ImportError(
                     "The aiohttp_socks python library is not installed and is required to use a socks proxy"
                 ) from err
-    elif proxy_config.disable_dns_cache:
-        # rewrite of async_ccxt.exchange.client.open()
-        _init_ccxt_client_session_requirements(client)
-        if client.session:
-            # should not happen
-            asyncio.create_task(client.session.close())
-        connector = aiohttp.TCPConnector(
-            ssl=client.ssl_context, loop=client.asyncio_loop, enable_cleanup_closed=True,
-            # local overrides
-            use_dns_cache=False
-            # end local overrides
-        )
-        client.session = aiohttp.ClientSession(
-            loop=client.asyncio_loop, connector=connector, trust_env=client.aiohttp_trust_env
-        )
 
 
 def _init_ccxt_client_session_requirements(client):
@@ -468,7 +452,7 @@ def _use_request_counter(
         # connector = aiohttp.TCPConnector(ssl=self.ssl_context, loop=self.asyncio_loop, enable_cleanup_closed=True)
         ccxt_client.tcp_connector = aiohttp.TCPConnector(
             ssl=ccxt_client.ssl_context, loop=ccxt_client.asyncio_loop,
-            enable_cleanup_closed=True, use_dns_cache=not proxy_config.disable_dns_cache
+            enable_cleanup_closed=True
         )
         counter_session = aiohttp_util.CounterClientSession(
             identifier,
@@ -490,6 +474,7 @@ def _use_request_counter(
 def ccxt_exchange_class_factory(exchange_name):
     return getattr(async_ccxt, exchange_name)
 
+
 def reraise_with_proxy_prefix_if_relevant(
     ccxt_connector, cause_error: Exception, raised_error: typing.Optional[Exception]
 ):

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/octobot_trading/personal_data/orders/order_factory.py

@@ -134,6 +134,7 @@ def create_order_from_dict(trader, order_dict):
         price=order_dict[enums.ExchangeConstantsOrderColumns.PRICE.value],
         status=enums.OrderStatus(order_dict[enums.ExchangeConstantsOrderColumns.STATUS.value]),
         order_id=order_dict[enums.ExchangeConstantsOrderColumns.ID.value],
+        exchange_order_id=order_dict.get(enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value),
         quantity_filled=order_dict[enums.ExchangeConstantsOrderColumns.FILLED.value],
         timestamp=order_dict[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value],
         side=enums.TradeOrderSide(order_dict[enums.ExchangeConstantsOrderColumns.SIDE.value]),

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -860,6 +860,18 @@ def get_assets_delta_from_orders(orders: list[order_import.Order]) -> (
                 asset_deltas[unit_and_amount[0]] = unit_and_amount[1] * multiplier
             else:
                 asset_deltas[unit_and_amount[0]] += unit_and_amount[1] * multiplier
+        if actual_fees := order.fee:
+            if (
+                actual_fees[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value] 
+                and actual_fees[enums.FeePropertyColumns.COST.value]
+            ):
+                # order fees are from exchange: add them to asset deltas as they are confirmed
+                fee_asset = actual_fees[enums.FeePropertyColumns.CURRENCY.value]
+                if fee_asset not in asset_deltas:
+                    # always substract fees
+                    asset_deltas[fee_asset] = -decimal.Decimal(str(actual_fees[enums.FeePropertyColumns.COST.value]))
+                else:
+                    asset_deltas[fee_asset] -= decimal.Decimal(str(actual_fees[enums.FeePropertyColumns.COST.value]))
         # 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(

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/requirements.txt

@@ -8,7 +8,7 @@ OctoBot-Tentacles-Manager>=2.9, <2.10
 trading-backend>=1.2.35
 
 # Exchange connection requirements
-ccxt==4.4.85 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
+ccxt==4.5.0 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
 
 cryptography # Never specify a version (managed by https://github.com/Drakkar-Software/OctoBot-PyPi-Linux-Deployer)
 

OctoBot-Trading-2.4.209/tests/exchanges/connectors/ccxt/test_ccxt_client_util.py

@@ -0,0 +1,179 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+import contextlib
+import pytest
+import mock
+import aiohttp
+import ccxt.async_support as ccxt
+
+import octobot_commons.aiohttp_util as aiohttp_util
+
+import octobot_trading.exchanges as exchanges
+import octobot_trading.exchanges.connectors.ccxt.ccxt_client_util as ccxt_client_util
+import octobot_trading.constants as constants
+
+
+@pytest.mark.asyncio
+async def test_proxies():
+    with mock.patch.object(aiohttp.ClientSession, "_request", mock.AsyncMock()) as _request_mock:
+
+        # no proxy
+        proxy_config = exchanges.ProxyConfig()
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] is None
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+        # http proxy
+        proxy_config = exchanges.ProxyConfig(
+            http_proxy="http://127.0.0.1:9090",
+        )
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] == "http://127.0.0.1:9090"
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+        # http proxy callback
+        proxy_config = exchanges.ProxyConfig(
+            http_proxy_callback=lambda url, method, headers, body: "http://9.9.9.9:9090",
+        )
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] == "http://9.9.9.9:9090"
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+        # https proxy
+        proxy_config = exchanges.ProxyConfig(
+            https_proxy="https://127.0.0.1:9090",
+        )
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] == "https://127.0.0.1:9090"
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+        # https proxy callback
+        proxy_config = exchanges.ProxyConfig(
+            https_proxy_callback=lambda url, method, headers, body: "https://9.9.9.9:9090",
+        )
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] == "https://9.9.9.9:9090"
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+        # https proxy callback
+        proxy_config = exchanges.ProxyConfig(
+            https_proxy_callback=lambda url, method, headers, body: "https://9.9.9.9:9090",
+        )
+        async with _exchange_with_proxy_config(proxy_config) as exchange:
+            _request_mock.assert_not_called()
+            await exchange.load_markets()
+            assert _request_mock.call_count > 0
+            assert all(
+                call.kwargs["proxy"] == "https://9.9.9.9:9090"
+                for call in _request_mock.call_args_list
+            )
+            _request_mock.reset_mock()
+
+
+@pytest.mark.asyncio
+async def test_request_counter():
+    with mock.patch.object(aiohttp.ClientSession, "_request", mock.AsyncMock()) as _request_mock:
+        # without proxy
+        proxy_config = exchanges.ProxyConfig()
+        with mock.patch.object(constants, "ENABLE_CCXT_REQUESTS_COUNTER", True):
+            async with _exchange_with_proxy_config(proxy_config, allow_request_counter=True) as exchange:
+                await exchange.load_markets()
+                assert _request_mock.call_count > 0
+                assert all(
+                    call.kwargs["proxy"] is None
+                    for call in _request_mock.call_args_list
+                )
+                assert isinstance(exchange.session, aiohttp_util.CounterClientSession)
+                # requests are counted by session counter
+                assert len(exchange.session.per_min.paths) > 0
+                assert exchange.session.per_min.paths[next(iter(exchange.session.per_min.paths))] > 0
+        _request_mock.reset_mock()
+
+        # with http proxy
+        proxy_config = exchanges.ProxyConfig(http_proxy="http://127.0.0.1:9090")
+        with mock.patch.object(constants, "ENABLE_CCXT_REQUESTS_COUNTER", True):
+            async with _exchange_with_proxy_config(proxy_config, allow_request_counter=True) as exchange:
+                await exchange.load_markets()
+                assert _request_mock.call_count > 0
+                assert all(
+                    call.kwargs["proxy"] == "http://127.0.0.1:9090"
+                    for call in _request_mock.call_args_list
+                )
+                assert isinstance(exchange.session, aiohttp_util.CounterClientSession)
+                # requests are counted by session counter
+                assert len(exchange.session.per_min.paths) > 0
+                assert exchange.session.per_min.paths[next(iter(exchange.session.per_min.paths))] > 0
+        _request_mock.reset_mock()
+
+        # with http proxy callback
+        proxy_config = exchanges.ProxyConfig(
+            http_proxy_callback=lambda url, method, headers, body: "http://9.9.9.9:9090"
+        )
+        with mock.patch.object(constants, "ENABLE_CCXT_REQUESTS_COUNTER", True):
+            async with _exchange_with_proxy_config(proxy_config, allow_request_counter=True) as exchange:
+                await exchange.load_markets()
+                assert _request_mock.call_count > 0
+                assert all(
+                    call.kwargs["proxy"] == "http://9.9.9.9:9090"
+                    for call in _request_mock.call_args_list
+                )
+                assert isinstance(exchange.session, aiohttp_util.CounterClientSession)
+                # requests are counted by session counter
+                assert len(exchange.session.per_min.paths) > 0
+                assert exchange.session.per_min.paths[next(iter(exchange.session.per_min.paths))] > 0
+        _request_mock.reset_mock()
+
+
+@contextlib.asynccontextmanager
+async def _exchange_with_proxy_config(proxy_config: exchanges.ProxyConfig, allow_request_counter=False):
+    exchange = None
+    try:
+        exchange = ccxt_client_util.instantiate_exchange(ccxt.kraken, {"enableRateLimit": False}, "test", proxy_config, allow_request_counter=allow_request_counter)
+        yield exchange
+    finally:
+        if exchange:
+            exchange.timeout_on_exit = 0    # avoid waiting for the exchange to close
+            await exchange.close()

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests/personal_data/orders/test_order_factory.py

@@ -134,6 +134,7 @@ class TestOrderFactory:
         # associated_entry_ids are not copied
         assert created_from_dict.associated_entry_ids is None
         assert created_from_dict.trigger_above is limit_order.trigger_above is True
+        assert created_from_dict.exchange_order_id # ensure exchange_order_id is generated
         assert limit_order.associated_entry_ids == ["1"]
 
 
@@ -146,6 +147,7 @@ class TestOrderFactory:
             quantity,
             price=price,
             trigger_above=False,
+            exchange_order_id="123",
         )
         order_dict = limit_order.to_dict()
         created_from_dict = personal_data.create_order_from_dict(trader_inst, order_dict)
@@ -160,6 +162,7 @@ class TestOrderFactory:
         # associated_entry_ids are not copied
         assert created_from_dict.associated_entry_ids is None
         assert created_from_dict.trigger_above is limit_order.trigger_above is False
+        assert created_from_dict.exchange_order_id == "123"
         assert limit_order.associated_entry_ids is None
 
         await self.stop(exchange_manager)

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests/personal_data/portfolios/test_portfolio_util.py

@@ -1028,6 +1028,90 @@ def test_get_portfolio_filled_orders_deltas_considering_local_exchange_fees():
         error_log.assert_not_called()
 
 
+def test_get_portfolio_filled_orders_deltas_with_exchange_fetched_fees():
+    pre_trade_content = _content({"BTC": 0.1, "USDT": 600.2})
+    post_trade_content = _content({"BTC": 0.2, "USDT": 50.2})    # paid 50 USDT in fees
+    error_log = mock.Mock()
+    with mock.patch.object(octobot_commons.logging, "get_logger", mock.Mock(return_value=mock.Mock(error=error_log))):
+        # no filled order
+        assert personal_data.get_portfolio_filled_orders_deltas(pre_trade_content, post_trade_content, [], []) == _resolved(
+            {}, {}
+        )
+        error_log.assert_not_called()
+
+        # with fees: delta is found
+        filled_orders = [
+            _order("BTC/USDT", 0.06, 100, "buy", {"USDT": 25}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.05, 450, "buy", {"USDT": 25}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.01, 50, "sell", {"BTC": 0.0000001}, is_exchange_fetched_fee=True),
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders, []
+        ) == _resolved(
+            # all orders found in deltas because fees have been taken into account
+            _content({"BTC": 0.1, "USDT": -550}),
+        )
+        for order in filled_orders:
+            assert order.get_computed_fee.call_count > 0
+        error_log.assert_not_called()
+
+        # now with unknown orders
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, [], filled_orders
+        ) == _resolved(
+            # all orders found in deltas because fees have been taken into account
+            explained_orders_deltas=_content({"BTC": 0.1, "USDT": -550}),
+            inferred_filled_orders=filled_orders,
+        )
+        error_log.assert_not_called()
+
+        # same test but fees will be much lower and won't explain all detlas
+        filled_orders = [
+            _order("BTC/USDT", 0.06, 100, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.05, 450, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.01, 50, "sell", {"BTC": 0.0000001}, is_exchange_fetched_fee=True),
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, filled_orders, []
+        ) == _resolved(
+            # only the part actually explained by fetched fees are taken into account in deltas (instead of -550 USDT)
+            _content({"BTC": 0.1, "USDT": -500.2}),
+        )
+        error_log.assert_not_called()
+
+        # now with unknown orders
+        unknown_orders = [
+            _order("BTC/USDT", 0.06, 100, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.05, 450, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.01, 50, "sell", {"BTC": 0.0000001}, is_exchange_fetched_fee=True),
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, [], unknown_orders
+        ) == _resolved(
+            # only the part actually explained by fetched fees are taken into account in deltas (instead of -550 USDT)
+            explained_orders_deltas=_content({"BTC": 0.1, "USDT": -500.2}),
+            inferred_filled_orders=unknown_orders,
+        )
+        error_log.assert_not_called()
+
+        # with an order that is not explained in deltas at all
+        unknown_orders = [
+            _order("BTC/USDT", 0.06, 100, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.05, 450, "buy", {"USDT": 0.1}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.01, 50, "sell", {"BTC": 0.0000001}, is_exchange_fetched_fee=True),
+            _order("BTC/USDT", 0.05, 50, "sell", {"BTC": 0.0000001}, is_exchange_fetched_fee=True), # not explained
+        ]
+        assert personal_data.get_portfolio_filled_orders_deltas(
+            pre_trade_content, post_trade_content, [], unknown_orders
+        ) == _resolved(
+            # only the part actually explained by fetched fees are taken into account in deltas (instead of -550 USDT)
+            explained_orders_deltas=_content({"BTC": 0.1, "USDT": -500.2}),
+            inferred_filled_orders=unknown_orders[:-1],
+            inferred_cancelled_orders=[unknown_orders[-1]],
+        )
+        error_log.assert_not_called()
+
+
 def test_get_accepted_missed_deltas():
     # with no delta
     post_trade_content = _content({"XRP": 40, "USDT": 129.2474232})
@@ -1353,7 +1437,7 @@ 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, local_fees_currencies: list[str] = []) -> personal_data.Order:
+def _order(symbol: str, quantity: float, cost: float, side: str, fee: dict = None, local_fees_currencies: list[str] = [], is_exchange_fetched_fee: bool = False) -> 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
@@ -1361,9 +1445,16 @@ def _order(symbol: str, quantity: float, cost: float, side: str, fee: dict = Non
     order.total_cost = decimal.Decimal(str(cost))
     order.origin_price = order.total_cost / order.origin_quantity
     order.side = enums.TradeOrderSide(side)
+    if is_exchange_fetched_fee:
+        order.fee = {
+            enums.FeePropertyColumns.COST.value: decimal.Decimal(str(next(iter(fee.values())) if fee else 0)),
+            enums.FeePropertyColumns.CURRENCY.value: next(iter(fee.keys())) if fee else None,
+            enums.FeePropertyColumns.IS_FROM_EXCHANGE.value: True,
+        }
+    # get_computed_fee returns empty fees when is_exchange_fetched_fee is True to avoid side effects with predicted fees
     order.get_computed_fee = mock.Mock(return_value={
-        enums.FeePropertyColumns.COST.value: decimal.Decimal(str(next(iter(fee.values())) if fee else 0)),
-        enums.FeePropertyColumns.CURRENCY.value: next(iter(fee.keys())) if fee else None,
+        enums.FeePropertyColumns.COST.value: decimal.Decimal(str(next(iter(fee.values())) if fee and not is_exchange_fetched_fee else 0)),
+        enums.FeePropertyColumns.CURRENCY.value: next(iter(fee.keys())) if fee and not is_exchange_fetched_fee else None,
         enums.FeePropertyColumns.IS_FROM_EXCHANGE.value: False,
     })
     return order

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/real_exchange_tester.py

@@ -123,7 +123,7 @@ class RealExchangeTester:
     async def test_get_historical_ohlcv(self):
         # common implementation, should always work if candles history is supported
         historical_ohlcv = await self.get_historical_ohlcv()
-        assert len(historical_ohlcv) > 500  # should be around 650
+        assert len(historical_ohlcv) > 500, f"{len(historical_ohlcv)=} < 500"  # should be around 650
         self.ensure_elements_order(historical_ohlcv, commons_enums.PriceIndexes.IND_PRICE_TIME.value)
         self.ensure_unique_elements(historical_ohlcv, commons_enums.PriceIndexes.IND_PRICE_TIME.value)
         start, end = self.get_historical_ohlcv_start_and_end_times()

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_ascendex.py

@@ -95,9 +95,6 @@ class TestAscendExRealExchangeTester(RealExchangeTester):
         # try with since and limit (used in data collector)
         for limit in (500, None):
             symbol_prices = await self.get_symbol_prices(since=self.CANDLE_SINCE, limit=limit)
-            # broken since ccxt==4.4.85
-            assert symbol_prices == []
-            continue
             if limit:
                 assert len(symbol_prices) == limit
             else:
@@ -111,8 +108,7 @@ class TestAscendExRealExchangeTester(RealExchangeTester):
                 assert self.CANDLE_SINCE_SEC <= candle[PriceIndexes.IND_PRICE_TIME.value] <= max_candle_time
 
     async def test_get_historical_ohlcv(self):
-        # broken since ccxt==4.4.85
-        assert await self.get_historical_ohlcv() == []
+        await super().test_get_historical_ohlcv()
 
     async def test_get_kline_price(self):
         kline_price = await self.get_kline_price()

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_bitfinex.py

@@ -54,7 +54,7 @@ class TestBitfinexRealExchangeTester(RealExchangeTester):
         ))
 
     async def test_active_symbols(self):
-        await self.inner_test_active_symbols(400, 400)
+        await self.inner_test_active_symbols(350, 350)
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_bitget.py

@@ -81,7 +81,7 @@ class TestBitgetRealExchangeTester(RealExchangeTester):
     async def test_get_symbol_prices(self):
         # without limit
         symbol_prices = await self.get_symbol_prices()
-        assert len(symbol_prices) == 100
+        assert len(symbol_prices) >=500, f"{len(symbol_prices)=} < 500"
         # check candles order (oldest first)
         self.ensure_elements_order(symbol_prices, PriceIndexes.IND_PRICE_TIME.value)
         # check last candle is the current candle

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_cryptocom.py

@@ -170,10 +170,10 @@ class TestCryptoComRealExchangeTester(RealExchangeTester):
             assert ticker[Ectc.BID_VOLUME.value] is None
             assert ticker[Ectc.ASK.value]
             assert ticker[Ectc.ASK_VOLUME.value] is None
-            assert ticker[Ectc.OPEN.value] is None
+            assert ticker[Ectc.OPEN.value]
             assert ticker[Ectc.CLOSE.value]
             assert ticker[Ectc.LAST.value]
             assert ticker[Ectc.PREVIOUS_CLOSE.value] is None
             assert ticker[Ectc.BASE_VOLUME.value]
             assert ticker[Ectc.TIMESTAMP.value]
-            RealExchangeTester.check_ticker_typing(ticker, check_open=False)
+            RealExchangeTester.check_ticker_typing(ticker)

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_gateio.py

@@ -160,10 +160,10 @@ class TestGateIORealExchangeTester(RealExchangeTester):
             assert ticker[Ectc.BID_VOLUME.value] is None
             assert ticker[Ectc.ASK.value]
             assert ticker[Ectc.ASK_VOLUME.value] is None
-            assert ticker[Ectc.OPEN.value] is None
+            assert ticker[Ectc.OPEN.value]
             assert ticker[Ectc.CLOSE.value]
             assert ticker[Ectc.LAST.value]
             assert ticker[Ectc.PREVIOUS_CLOSE.value] is None
             assert ticker[Ectc.BASE_VOLUME.value]
             assert ticker[Ectc.TIMESTAMP.value] is None  # will trigger an 'Ignored incomplete ticker'
-            RealExchangeTester.check_ticker_typing(ticker, check_open=False, check_timestamp=False)
+            RealExchangeTester.check_ticker_typing(ticker, check_timestamp=False)

{OctoBot-Trading-2.4.207 → OctoBot-Trading-2.4.209}/tests_additional/real_exchanges/test_hollaex.py

@@ -72,7 +72,7 @@ class TestHollaexRealExchangeTester(RealExchangeTester):
         # without limit is not supported replaced by a 500 default limit in hollaex tentacle
         symbol_prices = await self.get_symbol_prices(limit=500)
         # warning: large candle gaps, allow it in check
-        assert 30 <= len(symbol_prices) <= 500
+        assert len(symbol_prices) == 500
         # check candles order (oldest first)
         self.ensure_elements_order(symbol_prices, PriceIndexes.IND_PRICE_TIME.value)
         # check last candle is the current candle