OctoBot-Trading 2.4.122__tar.gz → 2.4.124__tar.gz

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/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.124] - 2024-11-17
+### Updated
+[Exchanges] Handle limit order in converter
+[Exchanges] Handle more ccxt missed orders
+
+## [2.4.123] - 2024-11-16
+### Updated
+[Requirements] Bump cachetools and make version more flexible
+
 ## [2.4.122] - 2024-11-14
 ### Fixed
 [Exchanges] Authorization header

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -8,4 +8,4 @@ ccxt==4.3.85
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2
-cachetools==5.3.2
+cachetools<6,>=5.5.0

{OctoBot-Trading-2.4.122/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.124}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/octobot_trading/errors.py

@@ -15,13 +15,19 @@
 #  License along with this library.
 
 
-class MissingFunds(Exception):
+class OctoBotExchangeError(Exception):
+    """
+    Parent class of local exceptions raised when communicating with exchanges
+    """
+
+
+class MissingFunds(OctoBotExchangeError):
     """
     Raised upon placing an order while having insufficient funds
     """
 
 
-class MissingMinimalExchangeTradeVolume(Exception):
+class MissingMinimalExchangeTradeVolume(OctoBotExchangeError):
     """
     Raised when a new order is impossible to create due to exchange minimal funds restrictions
     """
@@ -33,19 +39,19 @@ class TradingModeIncompatibility(Exception):
     """
 
 
-class OrderCreationError(Exception):
+class OrderCreationError(OctoBotExchangeError):
     """
     Raised upon a failed order creation
     """
 
 
-class OrderEditError(Exception):
+class OrderEditError(OctoBotExchangeError):
     """
     Raised upon a failed order edition
     """
 
 
-class OrderCancelError(Exception):
+class OrderCancelError(OctoBotExchangeError):
     """
     Raised upon a failed order cancel
     """
@@ -93,37 +99,44 @@ class NotSupported(Exception):
     """
 
 
-class FailedRequest(Exception):
+class FailedRequest(OctoBotExchangeError):
     """
     Raised upon a failed request on an exchange API
     """
 
 
-class RateLimitExceeded(Exception):
+class RateLimitExceeded(OctoBotExchangeError):
     """
     Raised upon an exchange API rate limit error
     """
 
 
-class UnavailableOrderTypeForMarketError(Exception):
+class UnavailableOrderTypeForMarketError(OctoBotExchangeError):
     """
     Raised when an exchange refuses to create a given type of order that should normally be supported
     """
 
 
-class AuthenticationError(Exception):
+class AuthenticationError(OctoBotExchangeError):
     """
     Raised when an exchange failed to authenticate
     """
 
 
-class ExchangeCompliancyError(Exception):
+class ExchangeInternalSyncError(OctoBotExchangeError):
+    """
+    Raised when an exchange is returning an error due to its internal sync process
+    (ex: when an order is filled but portfolio has not yet been updated)
+    """
+
+
+class ExchangeCompliancyError(OctoBotExchangeError):
     """
     Raised when an exchange failed to execute the given request because of compliance rules for the current user account
     """
 
 
-class ExchangeAccountSymbolPermissionError(Exception):
+class ExchangeAccountSymbolPermissionError(OctoBotExchangeError):
     """
     Raised when an exchange failed to execute the given request because of allowed traded symbols
     on the current user account

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -225,7 +225,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     @ccxt_client_util.converted_ccxt_common_errors
     async def _ensure_auth(self):
         try:
-            await self.get_balance()
+            await self.exchange_manager.exchange.get_balance()
         except (octobot_trading.errors.AuthenticationError, ccxt.AuthenticationError) as e:
             await self.client.close()
             self.unauthenticated_exchange_fallback(e)

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/octobot_trading/exchanges/types/rest_exchange.py

@@ -104,6 +104,10 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXCHANGE_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to account compliancy issues
     EXCHANGE_COMPLIANCY_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to exchange internal synch (like when portfolio is not yet up to date after a trade)
+    EXCHANGE_INTERNAL_SYNC_ERRORS: typing.List[typing.Iterable[str]] = []
+    # text content of errors due to missing fnuds when creating an order (when not identified as such by ccxt)
+    EXCHANGE_MISSING_FUNDS_ERRORS: typing.List[typing.Iterable[str]] = []
     # text content of errors due to exchange local account permissions (ex: accounts from X country can't trade XYZ)
     # text content of errors due to traded assets for account
     EXCHANGE_ACCOUNT_TRADED_SYMBOL_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = []
@@ -209,15 +213,18 @@ class RestExchange(abstract_exchange.AbstractExchange):
                                                quantity, price, stop_price, side,
                                                current_price, params)
 
+    def _on_missing_funds_err(self, err, order_type, symbol, quantity, price, stop_price):
+        self.log_order_creation_error(err, order_type, symbol, quantity, price, stop_price)
+        if self.__class__.PRINT_DEBUG_LOGS:
+            self.logger.warning(str(err))
+        raise errors.MissingFunds(err) from err
+
     @contextlib.asynccontextmanager
     async def _order_operation(self, order_type, symbol, quantity, price, stop_price):
         try:
             yield
         except ccxt.InsufficientFunds as e:
-            self.log_order_creation_error(e, order_type, symbol, quantity, price, stop_price)
-            if self.__class__.PRINT_DEBUG_LOGS:
-                self.logger.warning(str(e))
-            raise errors.MissingFunds(e) from e
+            self._on_missing_funds_err(e, order_type, symbol, quantity, price, stop_price)
         except ccxt.NotSupported as err:
             raise errors.NotSupported from err
         except (errors.AuthenticationError, ccxt.AuthenticationError) as err:
@@ -237,7 +244,8 @@ 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__} {e}") from e
-        except errors.ExchangeAccountSymbolPermissionError:
+        except errors.OctoBotExchangeError:
+            # custom error: forward it
             raise
         except Exception as e:
             if not self.is_market_open_for_order_type(symbol, order_type):
@@ -311,9 +319,18 @@ class RestExchange(abstract_exchange.AbstractExchange):
                 raise errors.ExchangeAccountSymbolPermissionError(
                     f"Error when creating {symbol} {order_type} order on {self.exchange_manager.exchange_name}: {err}"
                 ) from err
+            if self.is_exchange_internal_sync_error(err):
+                raise errors.ExchangeInternalSyncError(
+                    f"Error when handling order {err}. Exchange is refusing this order request because of sync error "
+                    f"({err})."
+                ) from err
+            if self.is_missing_funds_error(err):
+                self._on_missing_funds_err(err, order_type, symbol, quantity, price, stop_price)
             # can be raised when exchange precision/limits rules change
-            self.logger.debug(f"Failed to create order ({err}) : order_type: {order_type}, symbol: {symbol}. "
-                              f"This might be due to an update on {self.name} market rules. Fetching updated rules.")
+            self.logger.warning(
+                f"Failed to create order ({err}) : order_type: {order_type}, symbol: {symbol}. "
+                f"This might be due to an update on {self.name} market rules. Fetching updated rules."
+            )
             await self.connector.load_symbol_markets(reload=True, market_filter=self.exchange_manager.market_filter)
             # retry order creation with updated markets (ccxt will use the updated market values)
             return await self._create_specific_order(order_type, symbol, quantity, price=price,
@@ -948,6 +965,16 @@ class RestExchange(abstract_exchange.AbstractExchange):
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_COMPLIANCY_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)
+        return False
+
+    def is_missing_funds_error(self, error: BaseException) -> bool:
+        if self.EXCHANGE_MISSING_FUNDS_ERRORS:
+            return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_MISSING_FUNDS_ERRORS)
+        return False
+
     def is_exchange_account_traded_symbol_permission_error(self, error: BaseException) -> bool:
         if self.EXCHANGE_ACCOUNT_TRADED_SYMBOL_PERMISSION_ERRORS:
             return exchanges_util.is_error_on_this_type(error, self.EXCHANGE_ACCOUNT_TRADED_SYMBOL_PERMISSION_ERRORS)

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/octobot_trading/modes/modes_util.py

@@ -92,57 +92,71 @@ async def convert_asset_to_target_asset(
     tickers = tickers or {}
     portfolio = trading_mode.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.portfolio
     if asset in portfolio and portfolio[asset].available:
-        # get symbol of the order
-        symbol, order_type = _get_associated_symbol_and_order_type(trading_mode, asset, target_asset)
-        if symbol is None:
-            # can't convert asset into target_asset
-            trading_mode.logger.warning(
-                f"Impossible to convert {asset} into {target_asset}: no associated trading pair "
-                f"on {trading_mode.exchange_manager.exchange_name}"
-            )
-            return created_orders
+        created_orders.extend(
+            await convert_with_market_or_limit_order(trading_mode, asset, target_asset, tickers, asset_amount)
+        )
+    return created_orders
 
-        # get symbol price
-        price_base = asset
-        price_target = target_asset
-        if order_type is trading_enums.TraderOrderType.BUY_MARKET:
-            price_base = target_asset
-            price_target = asset
 
-        price = trading_personal_data.get_asset_price_from_converter_or_tickers(
-            trading_mode.exchange_manager, price_base, price_target, symbol, tickers
+async def convert_with_market_or_limit_order(
+    trading_mode, asset: str, target_asset: str, tickers: dict, asset_amount=None
+) -> list:
+    # get symbol of the order
+    symbol, order_type = _get_associated_symbol_and_order_type(trading_mode, asset, target_asset)
+    if symbol is None:
+        # can't convert asset into target_asset
+        trading_mode.logger.warning(
+            f"Impossible to convert {asset} into {target_asset}: no associated trading pair "
+            f"on {trading_mode.exchange_manager.exchange_name}"
         )
+        return []
 
-        if not price:
-            # can't get price, should not happen as symbol is in client_symbols
-            trading_mode.logger.error(
-                f"Impossible to convert {asset} into {target_asset}: {symbol} ticker can't be fetched"
-            )
-            return created_orders
-
-        if trading_personal_data.get_trade_order_type(order_type) is not trading_enums.TradeOrderType.MARKET:
-            # can't use market orders: use limit orders with price a bit under the current price to instant fill it.
-            price = get_instantly_filled_limit_order_adapted_price(price, order_type)
-
-        # get order quantity
-        quantity = _get_available_or_target_quantity(trading_mode, symbol, order_type, price, asset_amount)
-        symbol_market = trading_mode.exchange_manager.exchange.get_market_status(symbol, with_fixer=False)
-        for order_quantity, order_price in \
-                trading_personal_data.decimal_check_and_adapt_order_details_if_necessary(
-                    quantity,
-                    price,
-                    symbol_market
-                ):
-            # create order
-            order = trading_personal_data.create_order_instance(
-                trader=trading_mode.exchange_manager.trader,
-                order_type=order_type,
-                symbol=symbol,
-                current_price=price,
-                quantity=order_quantity,
-                price=order_price
-            )
-            created_orders.append(await trading_mode.create_order(order))
+    # get symbol price
+    price_base = asset
+    price_target = target_asset
+    if order_type is trading_enums.TraderOrderType.BUY_MARKET:
+        price_base = target_asset
+        price_target = asset
+
+    price = trading_personal_data.get_asset_price_from_converter_or_tickers(
+        trading_mode.exchange_manager, price_base, price_target, symbol, tickers
+    )
+
+    if not price:
+        # can't get price, should not happen as symbol is in client_symbols
+        trading_mode.logger.error(
+            f"Impossible to convert {asset} into {target_asset}: {symbol} ticker can't be fetched"
+        )
+        return []
+
+    if trading_personal_data.get_trade_order_type(order_type) is not trading_enums.TradeOrderType.MARKET:
+        # can't use market orders: use limit orders with price a bit under the current price to instant fill it.
+        price = get_instantly_filled_limit_order_adapted_price(price, order_type)
+
+    # get order quantity
+    quantity = _get_available_or_target_quantity(trading_mode, symbol, order_type, price, asset_amount)
+    symbol_market = trading_mode.exchange_manager.exchange.get_market_status(symbol, with_fixer=False)
+    created_orders = []
+    for order_quantity, order_price in \
+            trading_personal_data.decimal_check_and_adapt_order_details_if_necessary(
+                quantity,
+                price,
+                symbol_market
+            ):
+        # create order
+        order = trading_personal_data.create_order_instance(
+            trader=trading_mode.exchange_manager.trader,
+            order_type=order_type,
+            symbol=symbol,
+            current_price=price,
+            quantity=order_quantity,
+            price=order_price
+        )
+        initialized_order = await trading_mode.create_order(order)
+        if isinstance(initialized_order, trading_personal_data.LimitOrder) and initialized_order.simulated:
+            # on simulator, this order should be instantly filled now as its price is meant to be instantly filled
+            await initialized_order.on_fill()
+        created_orders.append(initialized_order)
     return created_orders
 
 

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/requirements.txt

@@ -19,4 +19,4 @@ sortedcontainers==2.4.0
 tinydb==4.5.2
 
 # Caching
-cachetools==5.3.2
+cachetools>=5.5.0, <6

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/tests/exchanges/connectors/ccxt/test_ccxt_connector.py

@@ -16,6 +16,7 @@
 #  License along with this library.
 import decimal
 
+import mock
 from mock import patch
 
 import octobot_trading.exchanges.connectors as exchange_connectors
@@ -58,11 +59,13 @@ async def test_initialize_impl_with_none_symbols_and_timeframes(ccxt_connector):
         def setSandboxMode(self, is_sandboxed):
             pass
 
-    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt:
+    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt, \
+            patch.object(ccxt_connector, '_ensure_auth', new=mock.AsyncMock()) as _ensure_auth_mock:
         await ccxt_connector.initialize_impl()
         assert ccxt_connector.symbols == set()
         assert ccxt_connector.time_frames == set()
         assert mocked_ccxt.set_markets_calls in ([[]], [])  # depends on call order
+        _ensure_auth_mock.assert_called_once()
 
 
 async def test_initialize_impl_with_empty_symbols_and_timeframes(ccxt_connector):
@@ -84,11 +87,13 @@ async def test_initialize_impl_with_empty_symbols_and_timeframes(ccxt_connector)
         def setSandboxMode(self, is_sandboxed):
             pass
 
-    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt:
+    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt, \
+            patch.object(ccxt_connector, '_ensure_auth', new=mock.AsyncMock()) as _ensure_auth_mock:
         await ccxt_connector.initialize_impl()
         assert ccxt_connector.symbols == set()
         assert ccxt_connector.time_frames == set()
         assert mocked_ccxt.set_markets_calls in ([[]], [])  # depends on call order
+        _ensure_auth_mock.assert_called_once()
 
 
 async def test_initialize_impl(ccxt_connector):
@@ -120,7 +125,8 @@ async def test_initialize_impl(ccxt_connector):
         def setSandboxMode(self, is_sandboxed):
             pass
 
-    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt:
+    with patch.object(ccxt_connector, 'client', new=MockCCXT()) as mocked_ccxt, \
+        patch.object(ccxt_connector, '_ensure_auth', new=mock.AsyncMock()) as _ensure_auth_mock:
         await ccxt_connector.initialize_impl()
         assert ccxt_connector.symbols == {
             "BTC/USDT",
@@ -133,6 +139,7 @@ async def test_initialize_impl(ccxt_connector):
             "4h",
         }
         assert mocked_ccxt.set_markets_calls in ([[]], [])  # depends on call order
+        _ensure_auth_mock.assert_called_once()
 
 
 async def test_set_symbol_partial_take_profit_stop_loss(ccxt_connector):

{OctoBot-Trading-2.4.122 → OctoBot-Trading-2.4.124}/tests/modes/test_modes_util.py

@@ -17,10 +17,12 @@ import mock
 import pytest
 import decimal
 
+import octobot_commons.asyncio_tools as asyncio_tools
 import octobot_trading.constants as constants
 import octobot_trading.enums as trading_enums
 import octobot_trading.personal_data as trading_personal_data
 import octobot_trading.modes.modes_util as modes_util
+import octobot_trading.signals as signals
 
 from tests.exchanges import backtesting_trader, backtesting_config, backtesting_exchange_manager, fake_backtesting
 from tests import event_loop
@@ -130,6 +132,10 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         assert order.symbol == "BTC/USDT"
         assert order.origin_quantity == decimal.Decimal(10)
         assert order.created_last_price == decimal.Decimal(30000)
+        # market order is instantly filled
+        assert order.is_filled()
+        assert order.filled_price == order.origin_price
+        assert order.filled_quantity > constants.ZERO
         trading_mode.create_order.assert_called_once()
         trading_mode.create_order.reset_mock()
         is_market_open_for_order_type_mock.assert_called_once_with(
@@ -142,8 +148,9 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     order = orders[0]
     assert order.order_type == trading_enums.TraderOrderType.BUY_MARKET
     assert order.symbol == "BTC/USDT"
-    assert order.origin_quantity == decimal.Decimal("0.03333333")
+    assert order.origin_quantity == decimal.Decimal("10.03333333")
     assert order.created_last_price == decimal.Decimal(30000)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
@@ -153,6 +160,8 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         trading_enums.ExchangeConstantsTickersColumns.CLOSE.value: decimal.Decimal(1500)
     }
 
+    # reset portfolio
+    portfolio["USDT"] = trading_personal_data.SpotAsset("USDT", decimal.Decimal(1000), decimal.Decimal(1000))
     orders = await modes_util.convert_asset_to_target_asset(trading_mode, "USDT", "ETH", tickers)
     assert len(orders) == 1
     order = orders[0]
@@ -160,15 +169,17 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     assert order.symbol == "ETH/USDT"
     assert order.origin_quantity == decimal.Decimal("0.66666666")
     assert order.created_last_price == decimal.Decimal(1500)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
+    portfolio["ETH"] = trading_personal_data.SpotAsset("ETH", constants.ZERO, constants.ZERO)
     orders = await modes_util.convert_asset_to_target_asset(trading_mode, "ETH", "USDT", tickers)
     # no ETH in portfolio
     assert orders == []
     trading_mode.create_order.assert_not_called()
 
-    portfolio["ETH"] = trading_personal_data.Asset("ETH", constants.ONE, constants.ONE)
+    portfolio["ETH"] = trading_personal_data.SpotAsset("ETH", constants.ONE, constants.ONE)
     orders = await modes_util.convert_asset_to_target_asset(trading_mode, "ETH", "USDT", tickers)
     assert len(orders) == 1
     order = orders[0]
@@ -176,10 +187,12 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     assert order.symbol == "ETH/USDT"
     assert order.origin_quantity == decimal.Decimal("1")
     assert order.created_last_price == decimal.Decimal(1500)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
     # with amount param
+    portfolio["ETH"] = trading_personal_data.SpotAsset("ETH", decimal.Decimal("2"), decimal.Decimal("2"))
     orders = await modes_util.convert_asset_to_target_asset(
         trading_mode, "ETH", "USDT", tickers, asset_amount=decimal.Decimal(2)
     )
@@ -189,6 +202,7 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     assert order.symbol == "ETH/USDT"
     assert order.origin_quantity == decimal.Decimal(2)
     assert order.created_last_price == decimal.Decimal(1500)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
@@ -201,6 +215,7 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     assert order.symbol == "ETH/USDT"
     assert order.origin_quantity == decimal.Decimal("0.3")
     assert order.created_last_price == decimal.Decimal(1500)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
@@ -213,6 +228,7 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     assert order.symbol == "ETH/USDT"
     assert order.origin_quantity == decimal.Decimal("0.66666666")
     assert order.created_last_price == decimal.Decimal(1500)
+    assert order.is_filled()
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
@@ -220,10 +236,12 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     fees = {
         trading_enums.FeePropertyColumns.COST.value: "2",
         trading_enums.FeePropertyColumns.CURRENCY.value: "USDT",
+        trading_enums.FeePropertyColumns.IS_FROM_EXCHANGE.value: True,
     }
     with mock.patch.object(exchange_manager.exchange, "get_trade_fee", mock.Mock(return_value=fees)) \
          as get_trade_fee_mock:
         # cast 1: enough funds in pf to cover fees
+        portfolio["USDT"] = trading_personal_data.SpotAsset("USDT", decimal.Decimal(1000), decimal.Decimal(1000))
         orders = await modes_util.convert_asset_to_target_asset(
             trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(450)
         )
@@ -233,12 +251,14 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         assert order.symbol == "ETH/USDT"
         assert order.origin_quantity == decimal.Decimal("0.3")
         assert order.created_last_price == decimal.Decimal(1500)
-        get_trade_fee_mock.assert_called_once()
+        assert order.is_filled()
+        assert get_trade_fee_mock.call_count == 4
         get_trade_fee_mock.reset_mock()
         trading_mode.create_order.assert_called_once()
         trading_mode.create_order.reset_mock()
 
         # cast 2: reduce amount to cover fees
+        portfolio["USDT"] = trading_personal_data.SpotAsset("USDT", decimal.Decimal(1000), decimal.Decimal(1000))
         orders = await modes_util.convert_asset_to_target_asset(
             trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(1000)
         )
@@ -248,7 +268,8 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         assert order.symbol == "ETH/USDT"
         assert order.origin_quantity == decimal.Decimal("0.66400000")   # lower than 0.66666666 when fees is 0 USDT
         assert order.created_last_price == decimal.Decimal(1500)
-        get_trade_fee_mock.assert_called_once()
+        assert order.is_filled()
+        assert get_trade_fee_mock.call_count == 4
         trading_mode.create_order.assert_called_once()
         trading_mode.create_order.reset_mock()
 
@@ -264,6 +285,7 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         mock.Mock(side_effect=_is_market_open_for_order_type)
     ) as is_market_open_for_order_type_mock:
         # cast 1: buying
+        portfolio["USDT"] = trading_personal_data.SpotAsset("USDT", decimal.Decimal(1000), decimal.Decimal(1000))
         orders = await modes_util.convert_asset_to_target_asset(
             trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(450)
         )
@@ -278,6 +300,10 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         )
         assert order.origin_price == adapted_price
         assert order.created_last_price == adapted_price
+        # limit order is designed to be instantly filled, on simulator it should be filled
+        assert order.is_filled()
+        assert order.filled_price == order.origin_price
+        assert order.filled_quantity > constants.ZERO
         assert is_market_open_for_order_type_mock.call_count == 2
         assert is_market_open_for_order_type_mock.mock_calls[0].args == \
                ("ETH/USDT", trading_enums.TraderOrderType.BUY_MARKET)
@@ -288,6 +314,7 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         trading_mode.create_order.reset_mock()
 
         # cast 2: selling
+        portfolio["USDT"] = trading_personal_data.SpotAsset("USDT", decimal.Decimal(2), decimal.Decimal(2))
         orders = await modes_util.convert_asset_to_target_asset(
             trading_mode, "ETH", "USDT", tickers, asset_amount=decimal.Decimal(2)
         )
@@ -301,6 +328,9 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
         )
         assert order.origin_price == adapted_price
         assert order.created_last_price == adapted_price
+        assert order.is_filled()
+        assert order.filled_price == order.origin_price
+        assert order.filled_quantity > constants.ZERO
         assert is_market_open_for_order_type_mock.call_count == 2
         assert is_market_open_for_order_type_mock.mock_calls[0].args == \
                ("ETH/USDT", trading_enums.TraderOrderType.SELL_MARKET)
@@ -312,7 +342,12 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
 
 
 def _get_trading_mode(exchange_manager):
+    async def _create_order(order):
+        return await signals.create_order(
+            exchange_manager, False, order
+        )
+
     return mock.Mock(
         exchange_manager=exchange_manager,
-        create_order=mock.AsyncMock(side_effect=lambda x: x)
+        create_order=mock.AsyncMock(side_effect=_create_order)
     )