OctoBot-Trading 2.4.98__tar.gz → 2.4.100__tar.gz

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/CHANGELOG.md

@@ -4,6 +4,18 @@ 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.100] - 2024-08-21
+### Added
+- [TradingModes] allow starting bot without enabled trading mode
+- [Tests] add active markets count tests
+### Updated
+- [Exchanges] use classmethods for autofilled exchanges
+- [Portfolio] add time window in history select
+
+## [2.4.99] - 2024-08-19
+### Updated
+- [CCXT] updated to ccxt 4.3.85
+
 ## [2.4.98] - 2024-08-16
 ### Added
 - [Exchanges] exchange_config_by_exchange in init

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -4,7 +4,7 @@ Async-Channel<2.3,>=2.2
 OctoBot-Commons<1.10,>=1.9.43
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.7
-ccxt==4.3.56
+ccxt==4.3.85
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2

{OctoBot-Trading-2.4.98/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.100}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/api/exchange.py

@@ -138,9 +138,8 @@ def get_matrix_id_from_exchange_id(exchange_name: str, exchange_id: str) -> str:
 
 def get_all_exchange_ids_from_matrix_id(matrix_id) -> list:
     return [
-        exchange_configuration.id
-        for exchange_configuration in exchanges.Exchanges.instance().get_all_exchanges()
-        if exchange_configuration.matrix_id == matrix_id
+        get_exchange_manager_id(exchange_manager)
+        for exchange_manager in exchanges.Exchanges.instance().get_exchanges_managers_with_matrix_id(matrix_id)
     ]
 
 

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/api/portfolio.py

@@ -15,6 +15,7 @@
 #  License along with this library.
 import decimal
 
+import octobot_commons.symbols as commons_symbols
 import octobot_trading.exchange_channel as exchange_channel
 import octobot_trading.constants
 import octobot_trading.personal_data as personal_data
@@ -105,4 +106,4 @@ def can_convert_symbol_to_usd_like(symbol: str) -> bool:
 
 
 def is_usd_like_coin(coin) -> bool:
-    return personal_data.ValueConverter.is_usd_like_coin(coin)
+    return commons_symbols.is_usd_like_coin(coin)

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/constants.py

@@ -69,14 +69,18 @@ ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV = os_util.parse_boolean_environment_var(
 ENABLE_CCXT_VERBOSE = os_util.parse_boolean_environment_var("ENABLE_CCXT_VERBOSE", "False")
 ENABLE_CCXT_RATE_LIMIT = os_util.parse_boolean_environment_var("ENABLE_CCXT_RATE_LIMIT", "True")
 THROTTLED_WS_UPDATES = float(os.getenv("THROTTLED_WS_UPDATES", "0.1"))  # avoid spamming CPU
-ENABLE_LIVE_CANDLES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_LIVE_CANDLES_STORAGE", "False")
-ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE", "False")
 MAX_CANDLES_IN_RAM = int(os.getenv("MAX_CANDLES_IN_RAM", "3000"))    # max candles per CandlesManager
 STORAGE_ORIGIN_VALUE = "origin_value"
 DISPLAY_TIME_FRAME = commons_enums.TimeFrames.ONE_HOUR
 DEFAULT_SUBACCOUNT_ID = "default_subaccount_id"
 DEFAULT_ACCOUNT_ID = "default_account_id"
 
+# Storage
+ENABLE_LIVE_CANDLES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_LIVE_CANDLES_STORAGE", "False")
+ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE", "False")
+ENABLE_SIMULATED_ORDERS_STORAGE = os_util.parse_boolean_environment_var("ENABLE_SIMULATED_ORDERS_STORAGE", "False")
+AUTH_UPDATE_DEBOUNCE_DURATION = float(os.getenv("AUTH_UPDATE_DEBOUNCE_DURATION", "10"))
+
 # Decimal default values (decimals are immutable, can be stored as constant)
 ZERO = decimal.Decimal(0)
 ONE = decimal.Decimal(1)
@@ -121,11 +125,12 @@ TESTED_EXCHANGES = [
     "mexc",
     "bingx",
     "coinex",
+    "bitmart",
 ])
 DEFAULT_FUTURE_EXCHANGES = sorted(["bybit"])
 SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bittrex",
                               "hitbtc", "kraken", "poloniex", "bitso", "ndax", "upbit",
-                              "wavesexchange", "bitmart",])
+                              "wavesexchange",])
 
 # text content of errors due to exchange compliancy rules
 # Warning: should never be a false positive

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/abstract_exchange.py

@@ -750,4 +750,7 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
     def _get_order_description(
         self, side: enums.TradeOrderSide, symbol: str, quantity: decimal.Decimal, price: decimal.Decimal
     ) -> str:
-        return f"{side.value}-{symbol}-{float(quantity)}-{float(price)}"
+        return (
+            f"{side.value if side else None}-{symbol}-"
+            f"{float(quantity) if quantity else None}-{float(price) if price else None}"
+        )

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/abstract_websocket_exchange.py

@@ -94,7 +94,7 @@ class AbstractWebsocketExchange:
     def get_exchange_credentials(self):
         """
         Exchange credentials
-        :return: key, secret, password
+        :return: key, secret, password, uid
         """
         return self.exchange_manager.get_exchange_credentials(self.exchange_manager.exchange_name)
 
@@ -219,7 +219,7 @@ class AbstractWebsocketExchange:
         raise NotImplementedError(f"get_feeds_count is not implemented")
 
     def _should_authenticate(self):
-        api_key, api_secret, _ = self.get_exchange_credentials()
+        api_key, api_secret, _, _ = self.get_exchange_credentials()
         return not self.exchange_manager.without_auth \
             and not self.exchange_manager.is_trader_simulated \
             and api_key and api_secret

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

@@ -43,6 +43,30 @@ class CCXTAdapter(adapters.AbstractAdapter):
         # CCXT standard order parsing logic
         return fixed
 
+    def adapt_amount_from_filled_or_cost(self, fixed):
+        try:
+            if (
+                fixed[enums.ExchangeConstantsOrderColumns.TYPE.value] == enums.TradeOrderType.MARKET.value and
+                fixed[enums.ExchangeConstantsOrderColumns.SIDE.value] == enums.TradeOrderSide.BUY.value and
+                fixed[enums.ExchangeConstantsOrderColumns.FILLED.value]
+            ):
+                # convert amount to use the base unit: use FILLED for accuracy (when not None/0)
+                fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value] = (
+                    fixed[enums.ExchangeConstantsOrderColumns.FILLED.value]
+                )
+            if (
+                (not fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value]) and
+                fixed[enums.ExchangeConstantsOrderColumns.COST.value] and
+                fixed[enums.ExchangeConstantsOrderColumns.PRICE.value]
+            ):
+                # convert amount to use the base unit
+                fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value] = (
+                    fixed[enums.ExchangeConstantsOrderColumns.COST.value] /
+                    fixed[enums.ExchangeConstantsOrderColumns.PRICE.value]
+                )
+        except KeyError:
+            pass
+
     def adapt_quantities_with_contract_size(self, order_or_trade, symbol):
         if self.connector.exchange_manager.is_future:
             symbol = symbol or order_or_trade.get(ecoc.SYMBOL.value)

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -45,15 +45,15 @@ def create_client(
                     f"exchange with ccxt in version {ccxt.__version__}")
     if exchange_manager.ignore_config or exchange_manager.check_config(exchange_manager.exchange_name):
         try:
-            key, secret, password = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
+            key, secret, password, uid = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
             if keys_adapter:
-                key, secret, password = keys_adapter(key, secret, password)
+                key, secret, password, uid = keys_adapter(key, secret, password, uid)
             if not (key and secret) and not exchange_manager.is_simulated and not exchange_manager.ignore_config:
                 logger.warning(f"No exchange API key set for {exchange_manager.exchange_name}. "
                                f"Enter your account details to enable real trading on this exchange.")
             if should_authenticate and not exchange_manager.is_backtesting:
                 client = exchange_class(_get_client_config(options, headers, additional_config,
-                                                           key, secret, password))
+                                                           key, secret, password, uid))
                 is_authenticated = True
                 if exchange_manager.check_credentials:
                     client.checkRequiredCredentials()
@@ -244,7 +244,7 @@ def _use_http_proxy_if_necessary(client):
     client.aiohttp_trust_env = constants.ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV
 
 
-def _get_client_config(options, headers, additional_config, api_key=None, secret=None, password=None):
+def _get_client_config(options, headers, additional_config, api_key=None, secret=None, password=None, uid=None):
     config = {
         'verbose': constants.ENABLE_CCXT_VERBOSE,
         'enableRateLimit': constants.ENABLE_CCXT_RATE_LIMIT,
@@ -258,5 +258,7 @@ def _get_client_config(options, headers, additional_config, api_key=None, secret
         config['secret'] = secret
     if password is not None:
         config['password'] = password
+    if uid is not None:
+        config['uid'] = uid
     config.update(additional_config or {})
     return config

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/exchange_builder.py

@@ -102,8 +102,13 @@ class ExchangeBuilder:
             raise e
 
     def _register_trading_modes_requirements(self, trading_mode_class, tentacles_setup_config):
-        self.exchange_manager.is_trading = trading_mode_class.get_is_trading_on_exchange(self.exchange_name,
-                                                                                         tentacles_setup_config)
+        self.exchange_manager.is_trading = trading_mode_class.get_is_trading_on_exchange(
+            self.exchange_name, tentacles_setup_config
+        )
+        if not self.exchange_manager.is_trading:
+            self.logger.info(
+                f"{self.exchange_manager.exchange_name} exchange is configured not to apply any trading strategy."
+            )
         # take trading modes candles requirements into account if any
         self.config[commons_constants.CONFIG_TENTACLES_REQUIRED_CANDLES_COUNT] = max(
             self.config[commons_constants.CONFIG_TENTACLES_REQUIRED_CANDLES_COUNT],

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/exchange_manager.py

@@ -306,7 +306,7 @@ class ExchangeManager(util.Initializable):
 
     def get_exchange_credentials(self, exchange_name):
         if self.ignore_config or not self.should_decrypt_token() or self.without_auth:
-            return "", "", ""
+            return "", "", "", ""
         config_exchange = self.config[common_constants.CONFIG_EXCHANGES][exchange_name]
         return (
             configuration.decrypt_element_if_possible(
@@ -317,7 +317,8 @@ class ExchangeManager(util.Initializable):
             ).strip(" "),   # remove leading and trailing whitespaces if any
             configuration.decrypt_element_if_possible(
                 common_constants.CONFIG_EXCHANGE_PASSWORD, config_exchange, None
-            )
+            ),
+            config_exchange.get(common_constants.CONFIG_EXCHANGE_UID, "")
         )
 
     def get_exchange_sub_account_id(self, exchange_name):

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/exchanges.py

@@ -59,6 +59,18 @@ class Exchanges(singleton.Singleton):
     def get_exchanges_list(self, exchange_name) -> list:
         return list(self.exchanges[exchange_name].values())
 
+    def get_exchanges_managers_with_matrix_id(self, matrix_id: str) -> list:
+        return [
+            exchange_configuration.exchange_manager
+            for exchange_configuration in self.get_all_exchanges()
+            if exchange_configuration.matrix_id == matrix_id
+        ]
+
+    def get_exchanges_managers_with_same_matrix_id(self, exchange_manager) -> list:
+        return self.get_exchanges_managers_with_matrix_id(
+            self.get_exchange(exchange_manager.exchange_name, exchange_manager.id).matrix_id
+        )
+
     def del_exchange(self, exchange_name, exchange_manager_id, should_warn=True) -> None:
         try:
             self.exchanges[exchange_name].pop(exchange_manager_id, None)

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/types/rest_exchange.py

@@ -950,8 +950,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     ):
         raise NotImplementedError("fetch_exchange_config")
 
-    @staticmethod
-    def supported_autofill_exchanges(tentacle_config):
+    @classmethod
+    def supported_autofill_exchanges(cls, tentacle_config):
         raise NotImplementedError("supported_autofill_exchanges is not implemented")
 
     @classmethod

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/modes/abstract_trading_mode.py

@@ -447,9 +447,9 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
     """
 
     @classmethod
-    def get_required_strategies_names_and_count(cls,
-                                                tentacles_config: tm_configuration.TentaclesSetupConfiguration,
-                                                trading_mode_config=None):
+    def get_required_strategies_names_and_count(
+        cls, tentacles_config: tm_configuration.TentaclesSetupConfiguration, trading_mode_config=None
+    ):
         config = trading_mode_config or tentacles_manager_api.get_tentacle_config(tentacles_config, cls)
         if constants.TRADING_MODE_REQUIRED_STRATEGIES in config:
             return config[constants.TRADING_MODE_REQUIRED_STRATEGIES], cls.get_required_strategies_count(config)

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/modes/mode_config.py

@@ -47,12 +47,14 @@ def get_activated_trading_mode(tentacles_setup_config):
 
                 if trading_mode_class is not None:
                     return trading_mode_class
-        except ModuleNotFoundError as e:
-            logging.get_logger("get_activated_trading_mode").error(f"Error when loading "
-                                                                   f"the activated trading mode: {e}")
+        except ModuleNotFoundError as err:
+            logging.get_logger("get_activated_trading_mode").error(
+                f"Error when loading the activated trading mode: {err}"
+            )
 
-    raise errors.ConfigTradingError(f"Please ensure your tentacles configuration file is valid and "
-                                    f"at least one trading mode is activated")
+    raise errors.ConfigTradingError(
+        "Please ensure your tentacles configuration file is valid and that a trading mode is activated"
+    )
 
 
 def should_emit_trading_signals_user_input(trading_mode, inputs: dict):

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/octobot_channel_consumer.py

@@ -20,9 +20,11 @@ import octobot_commons.channels_name as channels_name
 import octobot_commons.logging as logging
 import octobot_commons.enums as enums
 import octobot_commons.constants as commons_constants
+import octobot_commons.errors as commons_errors
 
 import octobot_trading.errors as errors
 import octobot_trading.exchanges as exchanges
+import octobot_trading.modes as modes
 import octobot_trading.util as util
 
 OCTOBOT_CHANNEL_TRADING_CONSUMER_LOGGER_TAG = "OctoBotChannelTradingConsumer"
@@ -70,6 +72,14 @@ async def _handle_creation(bot_id, action, data):
                 .has_matrix(data[OctoBotChannelTradingDataKeys.MATRIX_ID.value]) \
                 .use_tentacles_setup_config(data[OctoBotChannelTradingDataKeys.TENTACLES_SETUP_CONFIG.value]) \
                 .set_bot_id(bot_id)
+            try:
+                modes.get_activated_trading_mode(data[OctoBotChannelTradingDataKeys.TENTACLES_SETUP_CONFIG.value])
+            except commons_errors.ConfigTradingError:
+                logging.get_logger(OCTOBOT_CHANNEL_TRADING_CONSUMER_LOGGER_TAG).error(
+                    f"No configured trading mode. in order to trade, selected a profile with a trading mode."
+                )
+                # do not raise on missing trading mode
+                exchange_builder.disable_trading_mode()
             _set_exchange_type_details(exchange_builder, config, data[OctoBotChannelTradingDataKeys.BACKTESTING.value])
             await exchange_builder.build()
             await channel_instances.get_chan_at_id(

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/personal_data/portfolios/history/historical_portfolio_value_manager.py

@@ -157,10 +157,13 @@ class HistoricalPortfolioValueManager(util.Initializable):
         """
         to_timestamp = to_timestamp or self.portfolio_manager.exchange_manager.exchange.get_exchange_current_time()
         time_frame_seconds = commons_enums.TimeFramesMinutes[time_frame] * commons_constants.MINUTE_TO_SECONDS
+        sorted_available_timestamps = list(self.historical_portfolio_value)
         relevant_historical_values = [
             value
             for timestamp, value in self.historical_portfolio_value.items()
-            if self._is_historical_timestamp_relevant(timestamp, time_frame_seconds, from_timestamp, to_timestamp)
+            if self._is_historical_timestamp_relevant(
+                timestamp, time_frame_seconds, from_timestamp, to_timestamp, sorted_available_timestamps
+            )
         ]
         historical_values = {}
         for historical_value in relevant_historical_values:
@@ -252,15 +255,34 @@ class HistoricalPortfolioValueManager(util.Initializable):
                 if currency not in self.historical_starting_portfolio_values:
                     self.historical_starting_portfolio_values[currency] = value.get(currency)
 
-    def _is_historical_timestamp_relevant(self, timestamp, time_frame_seconds, from_timestamp, to_timestamp):
+    def _is_historical_timestamp_relevant(
+        self, timestamp, time_frame_seconds, from_timestamp, to_timestamp, sorted_available_timestamps: list
+    ):
         from_timestamp = from_timestamp or 0
         to_timestamp = to_timestamp or time.time()
-        return self._is_timestamp_relevant(timestamp, time_frame_seconds) and \
+        return self._is_timestamp_relevant(timestamp, time_frame_seconds, sorted_available_timestamps) and \
            from_timestamp <= timestamp <= to_timestamp
 
     @staticmethod
-    def _is_timestamp_relevant(timestamp, time_frame_seconds):
-        return timestamp % time_frame_seconds == 0
+    def _is_timestamp_relevant(timestamp, time_frame_seconds, sorted_available_timestamps: list):
+        if timestamp % time_frame_seconds == 0:
+            # timestamp is expected at this time
+            return True
+        else:
+            # timestamp is relevant only if there is no other available timestamp within the given timeframe range
+            current_timestamp_index = sorted_available_timestamps.index(timestamp)
+            allowed_delta = time_frame_seconds / 2
+            previous_timestamp = (
+                sorted_available_timestamps[current_timestamp_index - 1]
+                if current_timestamp_index > 0
+                else 0
+            )
+            next_timestamp = (
+                sorted_available_timestamps[current_timestamp_index + 1]
+                if current_timestamp_index < len(sorted_available_timestamps) - 1
+                else (timestamp + allowed_delta)
+            )
+            return previous_timestamp + allowed_delta <= timestamp <= next_timestamp - allowed_delta
 
     @staticmethod
     def convert_to_historical_timestamp(timestamp, time_frame):

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/personal_data/portfolios/value_converter.py

@@ -76,11 +76,11 @@ class ValueConverter:
         return self._check_currency_initialization(currency, currency_value)
 
     def get_usd_like_value(self, currency, quantity, raise_error=True, init_price_fetchers=True):
-        if self.is_usd_like_coin(currency):
+        if symbol_util.is_usd_like_coin(currency):
             return quantity
         if symbol := self.get_usd_like_symbol_from_symbols(currency, self.last_prices_by_trading_pair):
             base, quote = symbol_util.parse_symbol(symbol).base_and_quote()
-            usd_like_currency = base if self.is_usd_like_coin(base) else quote
+            usd_like_currency = base if symbol_util.is_usd_like_coin(base) else quote
             return self.evaluate_value(
                 currency, quantity, raise_error=raise_error,
                 target_currency=usd_like_currency, init_price_fetchers=init_price_fetchers
@@ -116,10 +116,6 @@ class ValueConverter:
                 return True
         return False
 
-    @staticmethod
-    def is_usd_like_coin(coin) -> bool:
-        return coin in commons_constants.USD_LIKE_COINS
-
     def _check_currency_initialization(self, currency, currency_value):
         """
         Check if the currency has to be removed from self.initializing_symbol_prices and return currency_value

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/storage/abstract_storage.py

@@ -31,7 +31,6 @@ class AbstractStorage:
     LIVE_CHANNEL = None
     IS_HISTORICAL = True
     HISTORY_TABLE = None
-    AUTH_UPDATE_DEBOUNCE_DURATION = 10
     FLUSH_DEBOUNCE_DURATION = 5   # avoid disc spam on multiple quick live updated
 
     def __init__(self, exchange_manager, plot_settings: commons_display.PlotSettings,
@@ -123,7 +122,7 @@ class AbstractStorage:
 
     async def _waiting_update_auth_data(self, reset):
         try:
-            await asyncio.sleep(self.AUTH_UPDATE_DEBOUNCE_DURATION)
+            await asyncio.sleep(trading_constants.AUTH_UPDATE_DEBOUNCE_DURATION)
             await self._update_auth_data(reset)
         except Exception as err:
             logging.get_logger(self.__class__.__name__).exception(err, True, f"Error when updating auth data: {err}")

{OctoBot-Trading-2.4.98 → OctoBot-Trading-2.4.100}/octobot_trading/storage/orders_storage.py

@@ -27,6 +27,7 @@ import octobot_trading.enums as enums
 import octobot_trading.constants as constants
 import octobot_trading.storage.abstract_storage as abstract_storage
 import octobot_trading.storage.util as storage_util
+import octobot_trading.exchanges as exchanges
 
 
 class OrdersStorage(abstract_storage.AbstractStorage):
@@ -36,13 +37,16 @@ class OrdersStorage(abstract_storage.AbstractStorage):
     ENABLE_HISTORICAL_ORDER_UPDATES_STORAGE = constants.ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE
 
     def __init__(self, exchange_manager, use_live_consumer_in_backtesting=None, is_historical=None):
-        super().__init__(exchange_manager, plot_settings=None,
-                         use_live_consumer_in_backtesting=use_live_consumer_in_backtesting, is_historical=is_historical)
+        super().__init__(
+            exchange_manager, plot_settings=None,
+            use_live_consumer_in_backtesting=use_live_consumer_in_backtesting, is_historical=is_historical
+        )
         self.startup_orders = {}
 
     def should_store_data(self):
-        return not self.exchange_manager.is_trader_simulated \
-            and not self.exchange_manager.is_backtesting
+        return (
+            constants.ENABLE_SIMULATED_ORDERS_STORAGE or not self.exchange_manager.is_trader_simulated
+        ) and not self.exchange_manager.is_backtesting
 
     async def on_start(self):
         await self._load_startup_orders()
@@ -86,13 +90,19 @@ class OrdersStorage(abstract_storage.AbstractStorage):
 
     async def _update_auth_data(self, _):
         authenticator = authentication.Authenticator.instance()
-        snapshot = [
-            _format_order(order, self.exchange_manager)
-            for order in self.exchange_manager.exchange_personal_data.orders_manager.get_open_orders()
-        ]
+
+        orders_by_exchange = {
+            exchange_manager.exchange_name: [
+                _format_order(order, exchange_manager)
+                for order in exchange_manager.exchange_personal_data.orders_manager.get_open_orders()
+            ]
+            for exchange_manager in exchanges.Exchanges.instance().get_exchanges_managers_with_same_matrix_id(
+                self.exchange_manager
+            )
+        }
         if authenticator.is_initialized():
             # also update when history is empty to reset trade history
-            await authenticator.update_orders(snapshot, self.exchange_manager.exchange_name)
+            await authenticator.update_orders(orders_by_exchange)
 
     async def _store_history(self):
         await self._update_history()