OctoBot-Trading 2.4.114__tar.gz → 2.4.116__tar.gz

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/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.116] - 2024-10-23
+### Added
+[Exchanges] handle proxy config
+[Exchanges] handle access token auth
+
+## [2.4.115] - 2024-10-21
+### Added
+[Orders] add get_valid_split_orders
+
 ## [2.4.114] - 2024-10-02
 ### Updated
 [Exchanges] handle creds with " or ' leading/trailing chars 

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -96,6 +96,7 @@ octobot_trading/exchanges/adapters/abstract_adapter.py
 octobot_trading/exchanges/config/__init__.py
 octobot_trading/exchanges/config/backtesting_exchange_config.py
 octobot_trading/exchanges/config/exchange_config_data.py
+octobot_trading/exchanges/config/proxy_config.py
 octobot_trading/exchanges/connectors/__init__.py
 octobot_trading/exchanges/connectors/ccxt/__init__.py
 octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

{OctoBot-Trading-2.4.114/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.116}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/constants.py

@@ -66,7 +66,11 @@ DEFAULT_FAILED_REQUEST_RETRY_TIME = 1
 FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS = 5
 DEFAULT_REQUEST_TIMEOUT = int(os.getenv("DEFAULT_REQUEST_TIMEOUT", "20000"))    # default ccxt is 10s, use 20
 ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV = os_util.parse_boolean_environment_var(
-    "ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV", "True")
+    "ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV", "True"
+)
+EXCHANGE_HTTP_PROXY_AUTHENTICATED_URL = os.getenv("EXCHANGE_HTTP_PROXY_AUTHENTICATED_URL")
+EXCHANGE_HTTPS_PROXY_AUTHENTICATED_URL = os.getenv("EXCHANGE_HTTPS_PROXY_AUTHENTICATED_URL")
+EXCHANGE_SOCKS_PROXY_AUTHENTICATED_URL = os.getenv("EXCHANGE_SOCKS_PROXY_AUTHENTICATED_URL")
 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")
 CCXT_DEFAULT_CACHE_LIMIT = int(os.getenv("CCXT_DEFAULT_CACHE_LIMIT", "1000"))  # 1000: default ccxt value

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/__init__.py

@@ -94,6 +94,7 @@ from octobot_trading.exchanges import config
 from octobot_trading.exchanges.config import (
     ExchangeConfig,
     BacktestingExchangeConfig,
+    ProxyConfig,
 )
 from octobot_trading.exchanges import traders
 from octobot_trading.exchanges.traders import (
@@ -133,6 +134,7 @@ __all__ = [
     "AbstractAdapter",
     "ExchangeConfig",
     "BacktestingExchangeConfig",
+    "ProxyConfig",
     "ExchangeManager",
     "ExchangeBuilder",
     "create_exchange_builder_instance",

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/abstract_websocket_exchange.py

@@ -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.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/config/__init__.py

@@ -23,8 +23,13 @@ from octobot_trading.exchanges.config import backtesting_exchange_config
 from octobot_trading.exchanges.config.backtesting_exchange_config import (
     BacktestingExchangeConfig,
 )
+from octobot_trading.exchanges.config import proxy_config
+from octobot_trading.exchanges.config.proxy_config import (
+    ProxyConfig,
+)
 
 __all__ = [
     "ExchangeConfig",
     "BacktestingExchangeConfig",
+    "ProxyConfig",
 ]

OctoBot-Trading-2.4.116/octobot_trading/exchanges/config/proxy_config.py

@@ -0,0 +1,40 @@
+#  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 dataclasses
+import typing
+import octobot_trading.constants
+
+
+@dataclasses.dataclass
+class ProxyConfig:
+    # REST proxy
+    http_proxy: typing.Optional[str] = None
+    http_proxy_callback: typing.Optional[typing.Callable] = None
+    https_proxy: typing.Optional[str] = None
+    https_proxy_callback: typing.Optional[typing.Callable] = None
+    # Websocket proxy
+    socks_proxy : typing.Optional[str] = None
+    socks_proxy_callback: typing.Optional[typing.Callable] = None
+    # enable trust_env in exchange's aiohttp.ClientSession
+    aiohttp_trust_env: bool = octobot_trading.constants.ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV
+
+    @classmethod
+    def default_env_var_config(cls):
+        return cls(
+            http_proxy=octobot_trading.constants.EXCHANGE_HTTP_PROXY_AUTHENTICATED_URL or None,
+            https_proxy=octobot_trading.constants.EXCHANGE_HTTPS_PROXY_AUTHENTICATED_URL or None,
+            socks_proxy=octobot_trading.constants.EXCHANGE_SOCKS_PROXY_AUTHENTICATED_URL or None,
+        )

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -25,6 +25,7 @@ import octobot_trading.enums as enums
 import octobot_trading.errors as errors
 import octobot_trading.exchanges.connectors.ccxt.enums as ccxt_enums
 import octobot_trading.exchanges.connectors.ccxt.ccxt_clients_cache as ccxt_clients_cache
+import octobot_trading.exchanges.config.proxy_config as proxy_config_import
 import octobot_trading.exchanges.util.exchange_util as exchange_util
 
 
@@ -45,15 +46,23 @@ 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, uid = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
+            auth_token_header_prefix = None
+            key, secret, password, uid, auth_token = exchange_manager.get_exchange_credentials(
+                exchange_manager.exchange_name
+            )
             if keys_adapter:
-                key, secret, password, uid = keys_adapter(key, secret, password, uid)
+                key, secret, password, uid, auth_token, auth_token_header_prefix = keys_adapter(
+                    key, secret, password, uid, auth_token
+                )
             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, uid))
+                client = exchange_class(_get_client_config(
+                    options, headers, additional_config,
+                    api_key=key, secret=secret, password=password, uid=uid,
+                    auth_token=auth_token, auth_token_header_prefix=auth_token_header_prefix
+                ))
                 is_authenticated = True
                 if exchange_manager.check_credentials:
                     client.checkRequiredCredentials()
@@ -62,14 +71,16 @@ def create_client(
         except (ccxt.AuthenticationError, Exception) as e:
             if unauthenticated_exchange_fallback is None:
                 return get_unauthenticated_exchange(
-                    exchange_class, options, headers, additional_config
+                    exchange_class, options, headers, additional_config, exchange_manager.proxy_config
                 ), False
             return unauthenticated_exchange_fallback(e), False
     else:
-        client = get_unauthenticated_exchange(exchange_class, options, headers, additional_config)
+        client = get_unauthenticated_exchange(
+            exchange_class, options, headers, additional_config, exchange_manager.proxy_config
+        )
         logger.error("configuration issue: missing login information !")
     client.logger.setLevel(logging.INFO)
-    _use_http_proxy_if_necessary(client)
+    _use_proxy_if_necessary(client, exchange_manager.proxy_config)
     return client, is_authenticated
 
 
@@ -95,9 +106,11 @@ async def close_client(client):
     client.orderbooks = {}
 
 
-def get_unauthenticated_exchange(exchange_class, options, headers, additional_config):
+def get_unauthenticated_exchange(
+    exchange_class, options, headers, additional_config, proxy_config: proxy_config_import.ProxyConfig
+):
     client = exchange_class(_get_client_config(options, headers, additional_config))
-    _use_http_proxy_if_necessary(client)
+    _use_proxy_if_necessary(client, proxy_config)
     return client
 
 
@@ -240,11 +253,29 @@ def converted_ccxt_common_errors(f):
     return converted_ccxt_common_errors_wrapper
 
 
-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, uid=None):
+def _use_proxy_if_necessary(client, proxy_config: proxy_config_import.ProxyConfig):
+    client.aiohttp_trust_env = proxy_config.aiohttp_trust_env
+    if proxy_config.http_proxy:
+        client.http_proxy = proxy_config.http_proxy
+    if proxy_config.http_proxy_callback:
+        client.http_proxy_callback = proxy_config.http_proxy_callback
+    if proxy_config.https_proxy:
+        client.https_proxy = proxy_config.https_proxy
+    if proxy_config.https_proxy_callback:
+        client.https_proxy_callback = proxy_config.https_proxy_callback
+    if proxy_config.socks_proxy:
+        client.socks_proxy = proxy_config.socks_proxy
+    if proxy_config.socks_proxy_callback:
+        client.socks_proxy_callback = proxy_config.socks_proxy_callback
+
+
+def _get_client_config(
+    options, headers, additional_config,
+    api_key=None, secret=None, password=None, uid=None,
+    auth_token=None, auth_token_header_prefix=None
+):
+    if auth_token is not None:
+        headers["Authorization"] = f"{auth_token_header_prefix or ''}{auth_token}"
     config = {
         'verbose': constants.ENABLE_CCXT_VERBOSE,
         'enableRateLimit': constants.ENABLE_CCXT_RATE_LIMIT,

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -256,7 +256,8 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             self.handle_token_error(err)
         return ccxt_client_util.get_unauthenticated_exchange(
             self.exchange_type,
-            self.options, self.headers, self.additional_config
+            self.options, self.headers, self.additional_config,
+            self.exchange_manager.proxy_config
         )
 
     def get_market_status(self, symbol, price_example=None, with_fixer=True):

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/exchange_builder.py

@@ -269,6 +269,10 @@ class ExchangeBuilder:
         self.exchange_manager.bot_id = bot_id
         return self
 
+    def set_proxy_config(self, proxy_config):
+        self.exchange_manager.proxy_config = proxy_config
+        return self
+
     def disable_trading_mode(self):
         self._is_using_trading_modes = False
         return self

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/exchange_factory.py

@@ -61,8 +61,17 @@ async def create_real_exchange(exchange_manager, exchange_config_by_exchange: ty
         if exchange_manager.exchange_only:
             return
         await _initialize_exchange_backend(exchange_manager)
-    except errors.AuthenticationError:
-        exchange_manager.logger.error("Authentication error, retrying without authentication...")
+    except errors.AuthenticationError as err:
+        if exchange_manager.without_auth:
+            # already retried, don't loop
+            exchange_manager.logger.error(
+                f"Authentication is required and created an error: impossible to connect to "
+                f"{exchange_manager.exchange_name} exchange: {err}"
+            )
+            raise
+        exchange_manager.logger.error(
+            f"Authentication error on {exchange_manager.exchange_name}, retrying without authentication..."
+        )
         exchange_manager.without_auth = True
         await create_real_exchange(exchange_manager, exchange_config_by_exchange)
         return

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/exchange_manager.py

@@ -58,6 +58,7 @@ class ExchangeManager(util.Initializable):
         self.without_auth: bool = False
         self.check_credentials: bool = True
         self.enable_storage: bool = True
+        self.proxy_config: exchanges.ProxyConfig = exchanges.ProxyConfig.default_env_var_config()
 
         # exchange_only is True when exchange channels are not required (therefore not created)
         self.exchange_only: bool = False
@@ -306,19 +307,23 @@ 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]
+        key = configuration.decrypt_element_if_possible(
+            common_constants.CONFIG_EXCHANGE_KEY, config_exchange, None
+        )
+        secret = configuration.decrypt_element_if_possible(
+            common_constants.CONFIG_EXCHANGE_SECRET, config_exchange, None
+        )
         return (
-            configuration.decrypt_element_if_possible(
-                common_constants.CONFIG_EXCHANGE_KEY, config_exchange, None
-            ).strip(' "').strip("'"),   # remove leading and trailing ", ' and whitespaces if any
-            configuration.decrypt_element_if_possible(
-                common_constants.CONFIG_EXCHANGE_SECRET, config_exchange, None
-            ).strip(' "').strip("'"),   # remove leading and trailing ", ' and whitespaces if any
+            # remove leading and trailing ", ' and whitespaces if any
+            key.strip(' "').strip("'") if key else key,
+            secret.strip(' "').strip("'") if secret else secret,
             configuration.decrypt_element_if_possible(
                 common_constants.CONFIG_EXCHANGE_PASSWORD, config_exchange, None
             ),
-            config_exchange.get(common_constants.CONFIG_EXCHANGE_UID, "")
+            config_exchange.get(common_constants.CONFIG_EXCHANGE_UID, ""),
+            config_exchange.get(common_constants.CONFIG_EXCHANGE_ACCESS_TOKEN, "")
         )
 
     def get_exchange_sub_account_id(self, exchange_name):

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/exchanges/traders/trader.py

@@ -321,6 +321,7 @@ class Trader(util.Initializable):
             order, chained_order.order_type
         )
         if is_bundled:
+            # warning: doesn't work for multiple stop loss / take profits
             if chained_order.order_type is enums.TraderOrderType.STOP_LOSS:
                 params.update(self.exchange_manager.exchange.get_bundled_order_parameters(
                     order,

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/personal_data/__init__.py

@@ -27,6 +27,7 @@ from octobot_trading.personal_data.orders import (
     is_valid,
     get_min_max_amounts,
     check_cost,
+    get_valid_split_orders,
     get_split_orders_count_and_increment,
     get_futures_max_order_size,
     get_max_order_quantity_for_price,
@@ -242,6 +243,7 @@ __all__ = [
     "is_valid",
     "get_min_max_amounts",
     "check_cost",
+    "get_valid_split_orders",
     "get_split_orders_count_and_increment",
     "get_futures_max_order_size",
     "get_max_order_quantity_for_price",

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/personal_data/orders/__init__.py

@@ -77,6 +77,7 @@ from octobot_trading.personal_data.orders.order_util import (
     is_valid,
     get_min_max_amounts,
     check_cost,
+    get_valid_split_orders,
     get_split_orders_count_and_increment,
     get_futures_max_order_size,
     get_max_order_quantity_for_price,
@@ -149,6 +150,7 @@ __all__ = [
     "is_valid",
     "get_min_max_amounts",
     "check_cost",
+    "get_valid_split_orders",
     "get_split_orders_count_and_increment",
     "get_futures_max_order_size",
     "get_max_order_quantity_for_price",

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/personal_data/orders/order_util.py

@@ -105,10 +105,41 @@ def check_cost(total_order_price, min_cost):
     return True
 
 
+def get_valid_split_orders(
+    quantity: decimal.Decimal, prices: list[decimal.Decimal], symbol_market
+) -> (list[decimal.Decimal], list[decimal.Decimal]):
+    if len(prices) < 1:
+        return [], []
+    if len(prices) < 2:
+        return [quantity], [prices[0]]
+    min_quantity, max_quantity, min_cost, max_cost, min_price, max_price = get_min_max_amounts(symbol_market)
+    min_quantity = None if min_quantity is None else decimal.Decimal(f"{min_quantity}")
+    max_quantity = None if max_quantity is None else decimal.Decimal(f"{max_quantity}")
+    min_cost = None if min_cost is None else decimal.Decimal(f"{min_cost}")
+    max_cost = None if max_cost is None else decimal.Decimal(f"{max_cost}")
+    min_price = None if min_price is None else decimal.Decimal(f"{min_price}")
+    max_price = None if max_price is None else decimal.Decimal(f"{max_price}")
+    # try to split quantity evenly amount prices
+    current_supported_orders_count = decimal.Decimal(str(len(prices)))
+    while current_supported_orders_count > constants.ONE:
+        order_vol = quantity / current_supported_orders_count
+        candidate_prices = prices[:int(current_supported_orders_count)]
+        first_price = min(candidate_prices)
+        last_price = max(candidate_prices)
+        if _are_orders_too_small(min_quantity, min_cost, min_price, first_price, order_vol):
+            # reduce orders count to increase quantity
+            current_supported_orders_count -= 1
+        elif _are_orders_too_large(max_quantity, max_cost, max_price, last_price, order_vol):
+            raise errors.InvalidArgumentError(f"Order volume ({order_vol}) is too large")
+        else:
+            return [order_vol] * int(current_supported_orders_count), candidate_prices
+    # default to full quantity and first price
+    return [quantity], [prices[0]]
+
+
 def get_split_orders_count_and_increment(
     lower_price, higher_price, quantity, orders_count, symbol_market, add_increment_to_min_price
-) \
-        -> (int, decimal.Decimal):
+) -> (int, decimal.Decimal):
     """
     :param lower_price: smallest order price
     :param higher_price: largest order price

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/octobot_trading/util/test_tools/exchange_data.py

@@ -33,6 +33,7 @@ class ExchangeAuthDetails(octobot_commons.dataclasses.FlexibleDataclass, octobot
     api_key: str = ""
     api_secret: str = ""
     api_password: str = ""
+    access_token: str = ""
     exchange_type: str = ""
     sandboxed: bool = False
     broker_enabled: bool = False

{OctoBot-Trading-2.4.114 → OctoBot-Trading-2.4.116}/tests/personal_data/orders/test_order_util.py

@@ -537,6 +537,71 @@ async def test_get_order_size_portfolio_percent(trader_simulator):
     ) == decimal.Decimal("10")
 
 
+def test_get_valid_split_orders():
+    # example SOL/BTC values from 12/09/2023
+    symbol_market = {
+        enums.ExchangeConstantsMarketStatusColumns.LIMITS.value: {
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT_MIN.value: 0.01,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT_MAX.value: 90000000.0,
+            },
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST_MIN.value: 0.0001,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST_MAX.value: 9000000.0
+            },
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE_MIN.value: 1e-07,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE_MAX.value: 1000.0
+            },
+        },
+        enums.ExchangeConstantsMarketStatusColumns.PRECISION.value: {
+            enums.ExchangeConstantsMarketStatusColumns.PRECISION_PRICE.value: 7,
+            enums.ExchangeConstantsMarketStatusColumns.PRECISION_AMOUNT.value: 2
+        }
+    }
+    # all valid values
+    prices = [
+        decimal.Decimal("0.0006858"),
+        decimal.Decimal("0.0006908"),
+        decimal.Decimal("0.0006938"),
+        decimal.Decimal("0.0006958"),
+    ]
+    assert personal_data.get_valid_split_orders(
+        decimal.Decimal("1"),
+        prices,
+        symbol_market
+    ) == ([decimal.Decimal("1") / len(prices)] * len(prices), prices)
+
+    # too small amount for cost: adapt to 3 orders
+    assert personal_data.get_valid_split_orders(
+        decimal.Decimal("0.5"),
+        prices,
+        symbol_market
+    ) == ([decimal.Decimal("0.5") / 3] * 3, prices[:3])
+
+    # too small amount for cost: adapt to 1 orders
+    assert personal_data.get_valid_split_orders(
+        decimal.Decimal("0.1"),
+        prices,
+        symbol_market
+    ) == ([decimal.Decimal('0.1')], [decimal.Decimal('0.0006858')])
+
+    # too small amount for cost (because of the lowest price order amount that gets truncated because of
+    # exchange precision rules): adapt to 0 orders
+
+    prices = [
+        decimal.Decimal("0.0006963"),
+        decimal.Decimal("0.0006908"),
+        decimal.Decimal("0.0006938"),
+        decimal.Decimal("0.0006958"),
+    ]
+    assert personal_data.get_valid_split_orders(
+        decimal.Decimal("0.14985"),
+        prices,
+        symbol_market,
+    ) == ([decimal.Decimal('0.14985')], [decimal.Decimal('0.0006963')])
+
+
 def test_get_split_orders_count_and_increment():
     # example SOL/BTC values from 12/09/2023
     symbol_market = {