OctoBot-Trading 2.4.138__tar.gz → 2.4.140__tar.gz

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/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.140] - 2025-01-03
+### Updated
+[Positions] properly clear closed positions
+[Exchanges] handle newline error in keys
+### Fixed
+[Exchanges] don't raise on missing order description
+[Orders] fix closed pos & instant fill chained orders
+
+## [2.4.139] - 2023-12-29
+### Updated
+[Simulator] handle futures backtesting with market status and different ccxt classes
+
 ## [2.4.138] - 2023-12-28
 ### Updated
 [TradingModes] ignore fees in futures chained orders

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/errors.py

@@ -143,6 +143,20 @@ class ExchangeAccountSymbolPermissionError(OctoBotExchangeError):
     """
 
 
+class ExchangeClosedPositionError(OctoBotExchangeError):
+    """
+    Raised when an exchange failed to execute the given request because the associated position is closed.
+    Can happen with reduce-only orders
+    """
+
+
+class ExchangeOrderInstantTriggerError(OctoBotExchangeError):
+    """
+    Raised when an exchange failed to execute the given request because the associated order would immediately trigger.
+    Can happen with stop orders
+    """
+
+
 class PortfolioNegativeValueError(Exception):
     """
     Raised when the portfolio is being updated with a negative value

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/abstract_exchange.py

@@ -742,7 +742,10 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
             self._creating_exchange_order_descriptions.add(desc)
             yield
         finally:
-            self._creating_exchange_order_descriptions.remove(desc)
+            try:
+                self._creating_exchange_order_descriptions.remove(desc)
+            except KeyError:
+                self.logger.error(f"Failed to remove {desc} from exchange order descriptions")
 
     def is_creating_order(
         self, order: dict, symbol: str

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -236,7 +236,11 @@ def get_pair_cryptocurrency(client, pair) -> str:
 
 
 def get_contract_size(client, pair) -> float:
-    return client.markets[pair][ccxt_enums.ExchangeConstantsMarketStatusCCXTColumns.CONTRACT_SIZE.value]
+    return get_market_status_contract_size(client.markets[pair])
+
+
+def get_market_status_contract_size(market_status: dict) :
+    return market_status[ccxt_enums.ExchangeConstantsMarketStatusCCXTColumns.CONTRACT_SIZE.value]
 
 
 def get_fees(market_status) -> dict:

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/connectors/simulator/ccxt_client_simulation.py

@@ -13,6 +13,8 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import decimal
+
 import octobot_trading.exchanges.connectors.ccxt.ccxt_client_util as ccxt_client_util
 
 
@@ -24,3 +26,7 @@ def parse_markets(exchange_name, market_filter) -> dict:
 
 def get_fees(market_status) -> dict:
     return ccxt_client_util.get_fees(market_status)
+
+
+def get_contract_size(market_status: dict) -> decimal.Decimal:
+    return decimal.Decimal(str(ccxt_client_util.get_market_status_contract_size(market_status)))

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/connectors/simulator/exchange_simulator_connector.py

@@ -76,12 +76,20 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
             return market[enums.ExchangeConstantsMarketStatusColumns.SYMBOL.value] in self.symbols
 
         self._forced_market_statuses = ccxt_client_simulation.parse_markets(
-            self.exchange_manager.exchange_class_string, market_filter
+            self._get_exchange_class_rest_name(), market_filter
         )
 
+    def _get_exchange_class_rest_name(self):
+        if self.exchange_manager.exchange.exchange_tentacle_class:
+            return self.exchange_manager.exchange.exchange_tentacle_class.get_rest_name(self.exchange_manager)
+        return self.exchange_manager.exchange_class_string
+
     def should_adapt_market_statuses(self) -> bool:
         return self.exchange_manager.use_cached_markets
 
+    def get_contract_size(self, symbol: str):
+        return ccxt_client_simulation.get_contract_size(self.get_market_status(symbol, with_fixer=False))
+
     @classmethod
     def load_user_inputs_from_class(cls, tentacles_setup_config, tentacle_config):
         # no user input in connector

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/exchange_manager.py

@@ -322,9 +322,9 @@ class ExchangeManager(util.Initializable):
             common_constants.CONFIG_EXCHANGE_SECRET, config_exchange, None
         )
         return (
-            # remove leading and trailing ", ' and whitespaces if any
-            key.strip(' "').strip("'") if key else key,
-            secret.strip(' "').strip("'") if secret else secret,
+            # remove leading and trailing ", ', newlines and whitespaces if any
+            key.strip(' "').strip("'").strip("\n") if key else key,
+            secret.strip(' "').strip("'").strip("\n") if secret else secret,
             configuration.decrypt_element_if_possible(
                 common_constants.CONFIG_EXCHANGE_PASSWORD, config_exchange, None
             ),

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/traders/trader.py

@@ -87,9 +87,10 @@ class Trader(util.Initializable):
     Orders
     """
 
-    async def create_order(self, order, loaded: bool = False, params: dict = None,
-                           wait_for_creation=True,
-                           creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
+    async def create_order(
+        self, order, loaded: bool = False, params: dict = None, wait_for_creation=True, raise_all_creation_error=False,
+        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+    ):
         """
         Create a new order from an OrderFactory created order, update portfolio, registers order in order manager and
         notifies order channel.
@@ -99,6 +100,8 @@ class Trader(util.Initializable):
         :param wait_for_creation: when True, always make sure the order is completely created before returning.
         On exchanges async api, a create request will return before the order is actually live on exchange, in this case
         the associated order state will make sure that the order is creating by polling the order from the exchange.
+        :param raise_all_creation_error: when True, will raise each ceation error when possible
+        (instead of retuning None)
         :param creation_timeout: time before raising a timeout error when waiting for an order creation
         :return: The crated order instance
         """
@@ -123,27 +126,34 @@ class Trader(util.Initializable):
             # forward errors that require actions to fix the situation
             raise
         except Exception as e:
+            if raise_all_creation_error:
+                raise
             self.logger.exception(e, True, f"Unexpected error when creating order: {e}. Order: {order}")
             return None
 
         return created_order
 
-    async def create_artificial_order(self, order_type, symbol, current_price, quantity, price,
-                                      emit_trading_signals=False,
-                                      wait_for_creation=True,
-                                      creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
+    async def create_artificial_order(
+        self, order_type, symbol, current_price, quantity, price, reduce_only, close_position,
+        emit_trading_signals=False, wait_for_creation=True,
+        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+    ):
         """
         Creates an OctoBot managed order (managed orders example: stop loss that is not published on the exchange and
         that is maintained internally).
         """
-        order = order_factory.create_order_instance(trader=self,
-                                                    order_type=order_type,
-                                                    symbol=symbol,
-                                                    current_price=current_price,
-                                                    quantity=quantity,
-                                                    price=price)
+        order = order_factory.create_order_instance(
+            trader=self,
+            order_type=order_type,
+            symbol=symbol,
+            current_price=current_price,
+            quantity=quantity,
+            price=price,
+            reduce_only=reduce_only,
+            close_position=close_position,
+        )
         async with signals.remote_signal_publisher(self.exchange_manager, order.symbol, emit_trading_signals):
-            await signals.create_order(
+            return await signals.create_order(
                 self.exchange_manager,
                 emit_trading_signals and signals.should_emit_trading_signal(self.exchange_manager),
                 order,

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/exchanges/types/rest_exchange.py

@@ -119,6 +119,10 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXCHANGE_ACCOUNT_TRADED_SYMBOL_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to unhandled authentication issues
     EXCHANGE_AUTHENTICATION_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to a closed position on the exchange. Relevant for reduce-only orders
+    EXCHANGE_CLOSED_POSITION_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to an order that would immediately trigger if created. Relevant for stop losses
+    EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS: typing.List[typing.Iterable[str]] = []
 
     DEFAULT_CONNECTOR_CLASS = ccxt_connector.CCXTConnector
 
@@ -138,7 +142,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
             exchange_manager,
             adapter_class=self.get_adapter_class(),
             additional_config=self.get_additional_connector_config(),
-            rest_name=self.get_rest_name(),
+            rest_name=self.get_rest_name(self.exchange_manager),
             force_auth=self.REQUIRES_AUTHENTICATION,
         )
 
@@ -166,8 +170,9 @@ class RestExchange(abstract_exchange.AbstractExchange):
         """
         return [enums.ExchangeTypes.SPOT]
 
-    def get_rest_name(self):
-        return self.exchange_manager.exchange_class_string
+    @classmethod
+    def get_rest_name(cls, exchange_manager):
+        return exchange_manager.exchange_class_string
 
     def get_associated_websocket_exchange_name(self):
         return self.exchange_manager.exchange_name
@@ -252,7 +257,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
             if self.should_log_on_ddos_exception(e):
                 self.connector.log_ddos_error(e)
             raise errors.FailedRequest(
-                f"Failed to order operation: {e.__class__.__name__} {html_util.get_html_summary_if_relevant(e)}"
+                f"Failed order operation: {e.__class__.__name__} {html_util.get_html_summary_if_relevant(e)}"
             ) from e
         except errors.OctoBotExchangeError:
             # custom error: forward it
@@ -275,6 +280,16 @@ class RestExchange(abstract_exchange.AbstractExchange):
                     f"Exchange is refusing this order request on this account because "
                     f"of its compliancy requirements."
                 ) from e
+            if self.is_exchange_closed_position_error(e):
+                raise errors.ExchangeClosedPositionError(
+                    f"Error when handling order {html_util.get_html_summary_if_relevant(e)}. "
+                    f"Exchange is refusing this order request because associated position is closed."
+                ) from e
+            if self.is_exchange_order_would_immediately_trigger_error(e):
+                raise errors.ExchangeOrderInstantTriggerError(
+                    f"Error when handling order {html_util.get_html_summary_if_relevant(e)}. "
+                    f"Exchange is refusing this order request because associated order would instantly trigger."
+                ) from e
             self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
             # print(traceback.format_exc(), file=sys.stderr)    # uncomment for debugging in tests
             self.logger.exception(
@@ -988,6 +1003,16 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_COMPLIANCY_ERRORS)
         return False
 
+    def is_exchange_closed_position_error(self, error: BaseException) -> bool:
+        if self.EXCHANGE_CLOSED_POSITION_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_CLOSED_POSITION_ERRORS)
+        return False
+
+    def is_exchange_order_would_immediately_trigger_error(self, error: BaseException) -> bool:
+        if self.EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_ORDER_IMMEDIATELY_TRIGGER_ERRORS)
+        return False
+
     def is_exchange_internal_sync_error(self, error: BaseException) -> bool:
         if self.EXCHANGE_INTERNAL_SYNC_ERRORS:
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_INTERNAL_SYNC_ERRORS)

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/personal_data/orders/order.py

@@ -24,6 +24,7 @@ import octobot_trading.constants as constants
 import octobot_trading.enums as enums
 import octobot_trading.errors as errors
 import octobot_trading.personal_data.orders.states as orders_states
+import octobot_trading.exchanges.traders.trader
 import octobot_trading.personal_data.orders.order_util as order_util
 import octobot_trading.personal_data.orders.decimal_order_adapter as decimal_order_adapter
 import octobot_trading.util as util
@@ -36,10 +37,11 @@ class Order(util.Initializable):
     It is also use to store creation & fill values of the order
     """
     CHECK_ORDER_STATUS_AFTER_INIT_DELAY = 2
+    SUPPORTS_GROUPING = True    # False when orders of this type can't be grouped
 
     def __init__(self, trader, side=None):
         super().__init__()
-        self.trader = trader
+        self.trader: octobot_trading.exchanges.traders.trader.Trader = trader
         self.exchange_manager = trader.exchange_manager
         self.lock = asyncio.Lock()
         self.is_synchronized_with_exchange = False
@@ -69,9 +71,9 @@ class Order(util.Initializable):
         self.origin_stop_price = constants.ZERO
 
         # order type attributes
-        self.order_type = None
+        self.order_type: enums.TraderOrderType = None
         # raw exchange order type, used to create order dict
-        self.exchange_order_type = None
+        self.exchange_order_type: enums.TradeOrderType = None
 
         # filled order attributes
         self.filled_quantity = constants.ZERO
@@ -112,6 +114,8 @@ class Order(util.Initializable):
         self.has_been_bundled = False
         # True when this order is to be opened as a chained order and has not been open yet
         self.is_waiting_for_chained_trigger = False
+        # instance of the order that has been created after self has been filled. Used in stop / TP orders
+        self.on_filled_artificial_order = None
 
         # Params given to the exchange request when this order is created. Include any exchange specific param here.
         # All params and values in those will be ignored in simulated orders
@@ -276,6 +280,17 @@ class Order(util.Initializable):
 
         return changed
 
+    async def create_on_filled_artificial_order(self, enable_associated_orders_creation):
+        """
+        :return: the equivalent artificial order after trigger price (ex: stop loss => market order)
+        """
+        await self.on_filled(enable_associated_orders_creation, force_artificial_orders=True)
+        if self.on_filled_artificial_order is not None:
+            logging.get_logger(self.logger_name).info(f"Created artificial order: {self.on_filled_artificial_order}")
+            if self.order_group:
+                self.on_filled_artificial_order.add_to_order_group(self.order_group)
+        return self.on_filled_artificial_order
+
     async def initialize_impl(self, **kwargs):
         """
         Initialize order status update tasks
@@ -432,8 +447,8 @@ class Order(util.Initializable):
             await self.state.initialize(forced=force_close)
 
     async def on_cancel(
-            self, is_from_exchange_data=False, force_cancel=False, enable_associated_orders_creation=None,
-            ignored_order=None
+        self, is_from_exchange_data=False, force_cancel=False, enable_associated_orders_creation=None,
+        ignored_order=None
     ):
         enable_associated_orders_creation = self.state.enable_associated_orders_creation \
             if (self.state and enable_associated_orders_creation is None) \
@@ -451,12 +466,12 @@ class Order(util.Initializable):
         """
         self.status = enums.OrderStatus.FILLED
 
-    async def on_filled(self, enable_associated_orders_creation):
+    async def on_filled(self, enable_associated_orders_creation, force_artificial_orders=False):
         """
         Filling complete callback
         """
         if enable_associated_orders_creation:
-            await self._trigger_chained_orders()
+            await self._trigger_chained_orders(enable_associated_orders_creation)
         elif self.chained_orders:
             logging.get_logger(self.get_logger_name()).info(
                 f"Skipped chained orders creation for {len(self.chained_orders)} chained orders: "
@@ -494,16 +509,68 @@ class Order(util.Initializable):
         Implement if necessary
         """
 
-    async def _trigger_chained_orders(self):
+    async def _trigger_chained_orders(self, enable_associated_orders_creation):
         logger = logging.get_logger(self.get_logger_name())
         for index, order in enumerate(self.chained_orders):
+            if order.is_cleared():
+                logger.error(
+                    f"Chained order {index + 1}/{len(self.chained_orders)} has been cleared: skipping "
+                    f"creation (order: {order})"
+                )
+                continue
             can_be_created = await order_util.adapt_chained_order_before_creation(self, order)
             if can_be_created and order.should_be_created():
                 logger.debug(f"Creating chained order {index + 1}/{len(self.chained_orders)}")
-                await order_util.create_as_chained_order(order)
+                await self._create_triggered_chained_order(order, enable_associated_orders_creation)
             else:
                 logger.debug(f"Skipping cancelled chained order {index + 1}/{len(self.chained_orders)}")
 
+    async def _create_triggered_chained_order(self, order, enable_associated_orders_creation):
+        logger = logging.get_logger(self.get_logger_name())
+        try:
+            await order_util.create_as_chained_order(order)
+        except errors.ExchangeClosedPositionError as err:
+            message = (
+                f"chained order is cancelled as it can't be created: position is closed "
+                f"on exchange ({err}) order: {order.id}"
+            )
+            if order.reduce_only:
+                # can happen on reduce only orders
+                logger.warning(f"Reduce only {message}")
+            else:
+                # should not happen on non-reduce only orders
+                logger.error(f"Unexpected: Non reduce only {message}")
+            # order can't be created: consider it cancelled
+            # note: grouped orders will also be skipped as this one is cancelled (should_be_created will be false)
+            order.status = octobot_trading.enums.OrderStatus.CLOSED
+            # clear state to avoid using outdated pending creation state
+            order.state = None
+            order.clear()
+        except errors.ExchangeOrderInstantTriggerError as err:
+            logger.info(f"Order would instantly trigger ({err}). Creating artificial order instead.")
+            equivalent_order = await order.create_on_filled_artificial_order(enable_associated_orders_creation)
+            if equivalent_order is None:
+                # should not happen on limit or market only orders
+                logger.error(f"Unexpected instant trigger error: {err} when creating chained order {order}")
+            else:
+                # acceptable: convert this order into its "triggered artificial order" equivalent
+                logger.warning(
+                    f"Outdated chained order: order trigger price has already been reached. "
+                    f"Creating equivalent {equivalent_order.get_name()} artificial order instead. "
+                    f"Initial order: {order}, artificial order: {equivalent_order}."
+                )
+            # note: grouped orders will also be skipped as this one is filled (should_be_created will be false)
+            order.status = octobot_trading.enums.OrderStatus.CLOSED
+            # clear state to avoid using outdated pending creation state
+            order.state = None
+            order.clear()
+        except Exception as err:
+            logger.exception(
+                err,
+                True,
+                f"Unexpected error ({err.__class__.__name__}: {err}) when creating chained order: {order}"
+            )
+
     async def set_as_chained_order(self, triggered_by, has_been_bundled, exchange_creation_params,
                                    update_with_triggering_order_fees, **trader_creation_kwargs):
         if triggered_by is self:
@@ -526,9 +593,19 @@ class Order(util.Initializable):
             return False
         for other_order in self.triggered_by.chained_orders:
             if other_order is self:
-                return False
-            if self.order_group is not None and self.order_group is other_order.order_group \
-                    and other_order.is_closed():
+                continue
+            order_to_check = (
+                other_order
+                if other_order.on_filled_artificial_order is None
+                else other_order.on_filled_artificial_order
+            )
+            if (
+                self.order_group is not None and self.order_group is order_to_check.order_group
+                and (
+                    order_to_check.is_closed()  # grouped order has been closed
+                    or not order_to_check.SUPPORTS_GROUPING # grouped order can't be used in groups (anymore)
+                )
+            ):
                 return True
         return False
 
@@ -758,7 +835,7 @@ class Order(util.Initializable):
 
         self.fee = order_util.parse_raw_fees(raw_order[enums.ExchangeConstantsOrderColumns.FEE.value])
 
-        self.executed_time = self.trader.exchange.get_uniformized_timestamp(
+        self.executed_time = self.trader.exchange_manager.exchange.get_uniformized_timestamp(
             raw_order[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value])
 
     def _update_type_from_raw(self, raw_order):

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/personal_data/orders/order_util.py

@@ -1,3 +1,4 @@
+# pylint: disable=W0706
 #  Drakkar-Software OctoBot-Trading
 #  Copyright (c) Drakkar-Software, All rights reserved.
 #
@@ -479,8 +480,12 @@ async def create_as_chained_order(order):
                 order,
                 loaded=False,
                 params=order.exchange_creation_params,
+                raise_all_creation_error=True,
                 **order.trader_creation_kwargs
             )
+        except (errors.ExchangeClosedPositionError, errors.ExchangeOrderInstantTriggerError):
+            # Order can be created and might be outdated forward error for the caller to fix it if possible
+            raise
         except Exception as err:
             # log warning to be sure to keep track of the failed order details
             logging.get_logger(LOGGER_NAME).warning(

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/personal_data/orders/types/limit/stop_loss_limit_order.py

@@ -34,14 +34,19 @@ class StopLossLimitOrder(limit_order.LimitOrder):
     async def update_price_if_outdated(self):
         pass
 
-    async def on_filled(self, enable_associated_orders_creation):
-        await limit_order.LimitOrder.on_filled(self, enable_associated_orders_creation)
-        # TODO replace with chained order ?
-        await self.trader.create_artificial_order(enums.TraderOrderType.SELL_MARKET
-                                                  if self.side is enums.TradeOrderSide.SELL
-                                                  else enums.TraderOrderType.BUY_MARKET,
-                                                  self.symbol, self.origin_stop_price,
-                                                  self.origin_quantity,
-                                                  self.limit_price
-                                                  if self.limit_price != self.UNINITIALIZED_LIMIT_PRICE else
-                                                  self.origin_stop_price)
+    async def on_filled(self, enable_associated_orders_creation, force_artificial_orders=False):
+        await limit_order.LimitOrder.on_filled(
+            self, enable_associated_orders_creation, force_artificial_orders=force_artificial_orders
+        )
+        order_type = (
+            enums.TraderOrderType.SELL_LIMIT
+            if self.side is enums.TradeOrderSide.SELL else enums.TraderOrderType.BUY_LIMIT
+        )
+        limit_price = (
+            self.limit_price
+            if self.limit_price != self.UNINITIALIZED_LIMIT_PRICE else self.origin_stop_price
+        )
+        self.on_filled_artificial_order = await self.trader.create_artificial_order(
+            order_type, self.symbol, self.origin_stop_price, self.origin_quantity, limit_price,
+            self.reduce_only, self.close_position
+        )

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/personal_data/orders/types/limit/stop_loss_order.py

@@ -32,12 +32,16 @@ class StopLossOrder(limit_order.LimitOrder):
         # Creates a market order when filled, which is taker
         return enums.ExchangeConstantsMarketPropertyColumns.TAKER.value
 
-    async def on_filled(self, enable_associated_orders_creation):
-        await limit_order.LimitOrder.on_filled(self, enable_associated_orders_creation)
-        if not self.trader.simulate and self.is_self_managed():
-            # TODO replace with chained order ?
-            await self.trader.create_artificial_order(enums.TraderOrderType.SELL_MARKET
-                                                      if self.side is enums.TradeOrderSide.SELL
-                                                      else enums.TraderOrderType.BUY_MARKET,
-                                                      self.symbol, self.origin_stop_price,
-                                                      self.origin_quantity, self.origin_stop_price)
+    async def on_filled(self, enable_associated_orders_creation, force_artificial_orders=False):
+        await limit_order.LimitOrder.on_filled(
+            self, enable_associated_orders_creation, force_artificial_orders=force_artificial_orders
+        )
+        if not self.trader.simulate and (self.is_self_managed() or force_artificial_orders):
+            order_type = (
+                enums.TraderOrderType.SELL_MARKET
+                if self.side is enums.TradeOrderSide.SELL else enums.TraderOrderType.BUY_MARKET
+            )
+            self.on_filled_artificial_order = await self.trader.create_artificial_order(
+                order_type, self.symbol, self.origin_stop_price, self.origin_quantity, self.origin_stop_price,
+                self.reduce_only, self.close_position
+            )

{OctoBot-Trading-2.4.138 → OctoBot-Trading-2.4.140}/octobot_trading/personal_data/orders/types/limit/take_profit_limit_order.py

@@ -29,14 +29,19 @@ class TakeProfitLimitOrder(limit_order.LimitOrder):
     async def update_price_if_outdated(self):
         pass
 
-    async def on_filled(self, enable_associated_orders_creation):
-        await limit_order.LimitOrder.on_filled(self, enable_associated_orders_creation)
-        # TODO replace with chained order ?
-        await self.trader.create_artificial_order(enums.TraderOrderType.SELL_LIMIT
-                                                  if self.side is enums.TradeOrderSide.SELL
-                                                  else enums.TraderOrderType.BUY_LIMIT,
-                                                  self.symbol, self.origin_stop_price,
-                                                  self.origin_quantity,
-                                                  self.limit_price
-                                                  if self.limit_price != self.UNINITIALIZED_LIMIT_PRICE else
-                                                  self.origin_stop_price)
+    async def on_filled(self, enable_associated_orders_creation, force_artificial_orders=False):
+        await limit_order.LimitOrder.on_filled(
+            self, enable_associated_orders_creation, force_artificial_orders=force_artificial_orders
+        )
+        order_type = (
+            enums.TraderOrderType.SELL_LIMIT
+            if self.side is enums.TradeOrderSide.SELL else enums.TraderOrderType.BUY_LIMIT
+        )
+        limit_price = (
+            self.limit_price
+            if self.limit_price != self.UNINITIALIZED_LIMIT_PRICE else self.origin_stop_price
+        )
+        self.on_filled_artificial_order = await self.trader.create_artificial_order(
+            order_type, self.symbol, self.origin_stop_price, self.origin_quantity, limit_price,
+            self.reduce_only, self.close_position
+        )