OctoBot-Trading 2.4.139__tar.gz → 2.4.141__tar.gz

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/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.141] - 2025-01-05
+### Added
+[TradingSignals] add positions and leverage update
+
+## [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

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/api/__init__.py

@@ -210,6 +210,7 @@ from octobot_trading.api.contracts import (
     get_pair_contracts,
     is_handled_contract,
     has_pair_future_contract,
+    update_pair_contract,
     load_pair_contract,
     create_default_future_contract,
 )
@@ -386,6 +387,7 @@ __all__ = [
     "get_pair_contracts",
     "is_handled_contract",
     "has_pair_future_contract",
+    "update_pair_contract",
     "load_pair_contract",
     "create_default_future_contract",
     "set_is_exclusively_using_exchange_position_details",

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/api/contracts.py

@@ -38,6 +38,10 @@ def has_pair_future_contract(exchange_manager, pair: str) -> bool:
     return exchange_manager.exchange.has_pair_future_contract(pair)
 
 
+def update_pair_contract(exchange_manager, pair: str, leverage: decimal.Decimal):
+    get_pair_contracts(exchange_manager)[pair].current_leverage = leverage
+
+
 def load_pair_contract(exchange_manager, contract_dict: dict):
     exchange_data.update_future_contract_from_dict(exchange_manager, contract_dict)
 

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/enums.py

@@ -521,6 +521,7 @@ class TradingSignalAttrs(enum.Enum):
 
 class TradingSignalTopics(enum.Enum):
     ORDERS = "orders"
+    POSITIONS = "positions"
     PORTFOLIO = "portfolio"
 
 
@@ -559,6 +560,15 @@ class TradingSignalOrdersAttrs(enum.Enum):
     UPDATE_WITH_TRIGGERING_ORDER_FEES = "update_with_triggering_order_fees"
 
 
+class TradingSignalPositionsAttrs(enum.Enum):
+    EXCHANGE = "exchange"
+    EXCHANGE_TYPE = "exchange_type"
+    STRATEGY = "strategy"
+    SYMBOL = "symbol"
+    SIDE = "side"
+    LEVERAGE = "leverage"
+
+
 class TradingSignalOrdersActions(enum.Enum):
     CREATE = "create"
     ADD_TO_GROUP = "add_to_group"
@@ -566,6 +576,10 @@ class TradingSignalOrdersActions(enum.Enum):
     CANCEL = "cancel"
 
 
+class TradingSignalPositionsActions(enum.Enum):
+    EDIT = "edit"
+
+
 class StoredOrdersAttr(enum.Enum):
     GROUP = "gr"
     GROUP_ID = "gi"

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/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
@@ -258,6 +272,12 @@ class OrderDescriptionNotFoundError(Exception):
     """
 
 
+class PositionDescriptionNotFoundError(Exception):
+    """
+    Raised when a position description is not found
+    """
+
+
 class AdapterError(Exception):
     """
     Raised when an error occurs in an adapter

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/exchange_data/contracts/margin_contract.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_commons.logging as logging
 
 import octobot_trading.enums as enums
@@ -24,12 +26,12 @@ class MarginContract:
                  contract_size=constants.ONE,
                  maximum_leverage=constants.ONE,
                  current_leverage=constants.ONE):
-        self.pair = pair
+        self.pair: str = pair
         self.margin_type = margin_type
 
-        self.contract_size = contract_size
-        self.maximum_leverage = maximum_leverage
-        self.current_leverage = current_leverage
+        self.contract_size: decimal.Decimal = contract_size
+        self.maximum_leverage: decimal.Decimal = maximum_leverage
+        self.current_leverage: decimal.Decimal = current_leverage
 
         self.risk_limit = {}
 
@@ -47,7 +49,12 @@ class MarginContract:
         :param new_leverage: the leverage value to check
         :return: True if valid
         """
-        return 0 < new_leverage if self.maximum_leverage is None else 0 < new_leverage <= self.maximum_leverage
+        dec_leverage = decimal.Decimal(str(new_leverage))
+        return (
+            constants.ZERO < dec_leverage
+            if self.maximum_leverage is None
+            else constants.ZERO < dec_leverage <= self.maximum_leverage
+        )
 
     def set_current_leverage(self, new_leverage):
         """

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/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.139 → OctoBot-Trading-2.4.141}/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.139 → OctoBot-Trading-2.4.141}/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,
@@ -769,13 +779,16 @@ class Trader(util.Initializable):
         async with self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.lock:
             await self.exchange_manager.exchange_personal_data.handle_portfolio_update_from_withdrawal(amount, currency)
 
-    async def set_leverage(self, symbol, side, leverage):
+    async def set_leverage(
+        self, symbol: str, side: typing.Optional[enums.PositionSide], leverage: decimal.Decimal
+    ) -> bool:
         """
         Updates the symbol contract leverage
         Can raise InvalidLeverageValue if leverage value is not matching requirements
         :param symbol: the symbol to update
         :param side: the side to update (TODO)
         :param leverage: the new leverage value
+        :return True if leverage changed
         """
         contract = self.exchange_manager.exchange.get_pair_future_contract(symbol)
         if not contract.check_leverage_update(leverage):
@@ -783,12 +796,11 @@ class Trader(util.Initializable):
                                               f"but maximal value is {contract.maximum_leverage}")
         if contract.current_leverage != leverage:
             if not self.simulate:
-                await self.exchange_manager.exchange.set_symbol_leverage(
-                    symbol=symbol,
-                    leverage=leverage
-                )
+                await self.exchange_manager.exchange.set_symbol_leverage(symbol, float(leverage))
             self.logger.info(f"Switching {symbol} leverage from {contract.current_leverage} to {leverage}")
             contract.set_current_leverage(leverage)
+            return True
+        return False
 
     async def set_symbol_take_profit_stop_loss_mode(self, symbol, new_mode: enums.TakeProfitStopLossMode):
         """

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/exchanges/types/rest_exchange.py

@@ -102,6 +102,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     CAN_HAVE_DELAYED_CANCELLED_ORDERS = False
     # Set True when the "limit" param when fetching order books is taken into account
     SUPPORTS_CUSTOM_LIMIT_ORDER_BOOK_FETCH = False
+    # Set False when the leverage value is set via something else that a set_leverage api (from orders for example)
+    UPDATE_LEVERAGE_FROM_API = True
 
     # text content of errors due to orders not found errors
     EXCHANGE_ORDER_NOT_FOUND_ERRORS: typing.List[typing.Iterable[str]] = []
@@ -119,6 +121,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
 
@@ -253,7 +259,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
@@ -276,6 +282,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(
@@ -920,7 +936,10 @@ class RestExchange(abstract_exchange.AbstractExchange):
         :param leverage: the leverage
         :return: the update result
         """
-        return await self.connector.set_symbol_leverage(leverage=leverage, symbol=symbol, **kwargs)
+        if self.UPDATE_LEVERAGE_FROM_API:
+            return await self.connector.set_symbol_leverage(leverage=leverage, symbol=symbol, **kwargs)
+        # nothing to do when UPDATE_LEVERAGE_FROM_API is False
+        return None
 
     async def set_symbol_margin_type(self, symbol: str, isolated: bool, **kwargs: dict):
         """
@@ -989,6 +1008,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.139 → OctoBot-Trading-2.4.141}/octobot_trading/modes/abstract_trading_mode.py

@@ -17,6 +17,7 @@ import abc
 import contextlib
 import decimal
 import copy
+import typing
 
 import octobot_commons.constants as common_constants
 import octobot_commons.enums as common_enums
@@ -585,6 +586,13 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
             params=params
         )
 
+    async def set_leverage(
+        self, symbol: str, side: typing.Optional[enums.PositionSide], leverage: decimal.Decimal
+    ) -> bool:
+        return await signals.set_leverage(
+            self.exchange_manager, self.should_emit_trading_signal(), symbol, side, leverage
+        )
+
     async def get_additional_metadata(self, is_backtesting):
         """
         Override if necessary

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/octobot_trading/modes/script_keywords/basic_keywords/configuration.py

@@ -42,9 +42,8 @@ async def user_select_emit_trading_signals(ctx, identifier, def_val=False) -> bo
     return is_emitting_signals
 
 
-async def set_leverage(ctx, leverage):
+async def set_leverage(ctx, leverage, side=None):
     if ctx.exchange_manager.is_future:
-        side = None
         try:
             await ctx.exchange_manager.trader.set_leverage(ctx.symbol, side, decimal.Decimal(str(leverage)))
         except errors.ContractExistsError as e:

{OctoBot-Trading-2.4.139 → OctoBot-Trading-2.4.141}/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.139 → OctoBot-Trading-2.4.141}/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(