OctoBot-Trading 2.4.51__tar.gz → 2.4.53__tar.gz

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/CHANGELOG.md

@@ -4,15 +4,26 @@ 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.51] - 2023-01-18
+## [2.4.53] - 2024-02-02
+### Fixed
+- [Orders] Handle quote-based fees in exchange simulator
+
+## [2.4.52] - 2024-01-30
+### Added
+- [API] Trades utility
+### Fixed
+- [Exchanges] Unidentified auth error in market status loading
+- [Exchanges] Fetch balance error spam on auth error
+
+## [2.4.51] - 2024-01-18
 ### Added
 - [CoinEx] Support CoinEx exchange
 
-## [2.4.50] - 2023-01-18
+## [2.4.50] - 2024-01-18
 ### Updated
 - [Websocket] Fix websocket reconnection after binance auto disconnect
 
-## [2.4.49] - 2023-01-08
+## [2.4.49] - 2024-01-08
 ### Updated
 - [Exchanges] replace Huobi by HTX
 - [CCXT] 4.2.10

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/api/__init__.py

@@ -51,6 +51,8 @@ from octobot_trading.api.symbol_data import (
 from octobot_trading.api.trades import (
     get_trade_history,
     get_completed_pnl_history,
+    is_executed_trade,
+    is_trade_after_or_at,
     get_total_paid_trading_fees,
     get_trade_exchange_name,
     parse_trade_type,
@@ -97,7 +99,7 @@ from octobot_trading.api.exchange import (
     get_new_ccxt_client,
     get_default_exchange_type,
     is_sponsoring,
-    is_valid_account,
+    is_broker_enabled,
     get_historical_ohlcv,
     get_bot_id,
     get_supported_exchange_types,
@@ -154,6 +156,7 @@ from octobot_trading.api.portfolio import (
     set_simulated_portfolio_initial_config,
     refresh_real_trader_portfolio,
     format_portfolio,
+    parse_decimal_portfolio,
     get_draw_down,
     get_coefficient_of_determination,
     get_usd_like_symbol_from_symbols,
@@ -229,6 +232,8 @@ __all__ = [
     "get_config_symbols",
     "get_trade_history",
     "get_completed_pnl_history",
+    "is_executed_trade",
+    "is_trade_after_or_at",
     "get_total_paid_trading_fees",
     "get_trade_exchange_name",
     "parse_trade_type",
@@ -271,7 +276,7 @@ __all__ = [
     "get_new_ccxt_client",
     "get_default_exchange_type",
     "is_sponsoring",
-    "is_valid_account",
+    "is_broker_enabled",
     "get_historical_ohlcv",
     "get_bot_id",
     "get_supported_exchange_types",
@@ -330,6 +335,7 @@ __all__ = [
     "get_origin_portfolio_value",
     "get_profitability_stats",
     "format_portfolio",
+    "parse_decimal_portfolio",
     "get_current_portfolio_value",
     "get_currency_ref_market_value",
     "get_current_holdings_values",

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/api/exchange.py

@@ -281,8 +281,8 @@ def is_sponsoring(exchange_name: str) -> bool:
     return trading_backend.is_sponsoring(exchange_name)
 
 
-def is_valid_account(exchange_manager) -> bool:
-    return exchange_manager.is_valid_account
+def is_broker_enabled(exchange_manager) -> bool:
+    return exchange_manager.is_broker_enabled
 
 
 def get_historical_ohlcv(

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/api/portfolio.py

@@ -73,6 +73,10 @@ def format_portfolio(portfolio, as_decimal) -> dict:
     return personal_data.portfolio_to_float(portfolio)
 
 
+def parse_decimal_portfolio(portfolio, as_decimal) -> dict:
+    return personal_data.parse_decimal_portfolio(portfolio, as_decimal=as_decimal)
+
+
 async def refresh_real_trader_portfolio(exchange_manager) -> bool:
     return await exchange_channel.get_chan(octobot_trading.constants.BALANCE_CHANNEL, exchange_manager.id). \
         get_internal_producer(). \

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/api/trades.py

@@ -50,7 +50,24 @@ def _trade_filter(trade, quote=None, symbol=None, timestamp=None, include_cancel
     return True
 
 
-def _is_trade_after_or_at(trade, timestamp) -> bool:
+def is_executed_trade(trade: dict) -> bool:
+    try:
+        return trade[octobot_trading.enums.ExchangeConstantsOrderColumns.STATUS.value] not in (
+            octobot_trading.enums.OrderStatus.CANCELED.value,
+            octobot_trading.enums.OrderStatus.EXPIRED.value,
+        )
+    except KeyError:
+        return False
+
+
+def is_trade_after_or_at(trade: dict, timestamp: float) -> bool:
+    try:
+        return trade[octobot_trading.enums.ExchangeConstantsOrderColumns.TIMESTAMP.value] >= timestamp
+    except KeyError:
+        return False
+
+
+def _is_trade_after_or_at(trade: personal_data.Trade, timestamp: float) -> bool:
     return trade.executed_time >= timestamp or trade.canceled_time >= timestamp
 
 

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/constants.py

@@ -64,6 +64,7 @@ ENABLE_CCXT_RATE_LIMIT = os_util.parse_boolean_environment_var("ENABLE_CCXT_RATE
 THROTTLED_WS_UPDATES = float(os.getenv("THROTTLED_WS_UPDATES", "0.1"))  # avoid spamming CPU
 ENABLE_LIVE_CANDLES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_LIVE_CANDLES_STORAGE", "False")
 ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE", "False")
+MAX_CANDLES_IN_RAM = int(os.getenv("MAX_CANDLES_IN_RAM", "3000"))    # max candles per CandlesManager
 STORAGE_ORIGIN_VALUE = "origin_value"
 DISPLAY_TIME_FRAME = commons_enums.TimeFrames.ONE_HOUR
 DEFAULT_SUBACCOUNT_ID = "default_subaccount_id"

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/enums.py

@@ -333,6 +333,7 @@ class ExchangeConstantsOrderColumns(enum.Enum):
     SELF_MANAGED = "self-managed"
     ENTRIES = "entries"
     VOLUME = "volume"
+    BROKER_APPLIED = "broker_applied"
 
 
 class TradeExtraConstants(enum.Enum):

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchange_data/ohlcv/candles_manager.py

@@ -20,10 +20,11 @@ import octobot_commons.enums as enums
 import octobot_commons.logging as logging
 
 import octobot_trading.util as util
+import octobot_trading.constants as constants
 
 
 class CandlesManager(util.Initializable):
-    MAX_CANDLES_COUNT = 1000
+    MAX_CANDLES_COUNT = constants.MAX_CANDLES_IN_RAM
 
     def __init__(self, max_candles_count=None):
         super().__init__()

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -125,6 +125,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             except KeyError:
                 load_markets = True
         if load_markets:
+            self.logger.info(f"Loading {self.exchange_manager.exchange_name} exchange markets")
             try:
                 await self.client.load_markets(reload=reload)
                 ccxt_client_util.set_markets_cache(self.client)
@@ -132,8 +133,9 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                 raise octobot_trading.errors.FailedRequest(
                     f"Failed to load_symbol_markets: {err.__class__.__name__} on {err}"
                 ) from err
-            except ccxt.AuthenticationError:
-                if not self.force_authentication:
+            except ccxt.ExchangeError:
+                # includes AuthenticationError but also auth error not identified as such by ccxt
+                if not self.force_authentication and self.is_authenticated:
                     self.logger.debug(
                         f"Credentials check enabled when fetching exchange market status, trying with "
                         f"unauthenticated client."
@@ -635,10 +637,12 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                                          price=float(price),
                                          takerOrMaker=taker_or_maker)
         fees[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value] = False
-        fees[enums.FeePropertyColumns.COST.value] = decimal.Decimal(str(fees[enums.FeePropertyColumns.COST.value]))
+        fees[enums.FeePropertyColumns.COST.value] = decimal.Decimal(
+            str(fees.get(enums.FeePropertyColumns.COST.value) or 0)
+        )
         if self.exchange_manager.is_future:
             # fees on futures are wrong
-            rate = fees[enums.FeePropertyColumns.RATE.value]
+            rate = fees.get(enums.FeePropertyColumns.RATE.value, 0) or 0
             # avoid using ccxt computed fees as they are often wrong
             # see https://docs.ccxt.com/en/latest/manual.html#trading-fees
             parsed_symbol = commons_symbols.parse_symbol(symbol)

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/connectors/ccxt/ccxt_websocket_connector.py

@@ -276,6 +276,7 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
         """
         try:
             self.initialized_event = asyncio.Event()
+            self.logger.info(f"Loading {self.exchange_manager.exchange_name} websocket exchange markets")
             await self.client.load_markets()
             self._filter_exchange_pairs_and_timeframes()
             self._subscribe_feeds()

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/exchange_builder.py

@@ -230,6 +230,10 @@ class ExchangeBuilder:
         self.exchange_manager.ignore_config = ignore_config
         return self
 
+    def is_broker_enabled(self, is_broker_enabled=False):
+        self.exchange_manager.is_broker_enabled = is_broker_enabled
+        return self
+
     def is_without_auth(self):
         self.exchange_manager.without_auth = True
         return self

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/exchange_factory.py

@@ -59,7 +59,6 @@ async def create_real_exchange(exchange_manager) -> None:
         if exchange_manager.exchange_only:
             return
         await _initialize_exchange_backend(exchange_manager)
-        _ensure_exchange_validity(exchange_manager)
     except errors.AuthenticationError:
         exchange_manager.logger.error("Authentication error, retrying without authentication...")
         exchange_manager.without_auth = True
@@ -78,21 +77,6 @@ async def initialize_real_exchange(exchange_manager):
             await exchanges.search_and_create_websocket(exchange_manager)
 
 
-def _ensure_exchange_validity(exchange_manager):
-    if exchange_manager.is_future and \
-            not exchange_manager.is_trader_simulated and \
-            not exchange_manager.is_valid_account:
-        error_message = f"Impossible to check exchange sponsoring due to" \
-                        f" {exchange_manager.init_error.__class__.__name__}." \
-            if isinstance(exchange_manager.init_error, trading_backend.TimeSyncError) \
-            else \
-            f"Impossible to start futures trading for {exchange_manager.exchange.name.capitalize()}: " \
-            f"incompatible account with no registered donation. Your OctoBot will work normally " \
-            f"for spot trading but will be *limited to backtesting for futures trading. " \
-            f"Please select spot trading on your exchange configuration."
-        raise errors.NotSupported(error_message)
-
-
 def _create_exchange_backend(exchange_manager):
     try:
         exchange_manager.exchange_backend = trading_backend.exchange_factory.create_exchange_backend(
@@ -106,32 +90,13 @@ async def _initialize_exchange_backend(exchange_manager):
     if exchange_manager.exchange_backend is not None and exchange_manager.exchange.authenticated() \
             and not exchange_manager.is_trader_simulated:
         exchange_manager.logger.debug(await exchange_manager.exchange_backend.initialize())
-        return
-        # disabled
-        try:    # pylint: disable=W0101
-            exchange_manager.is_valid_account = await _is_supporting_octobot()
-            if exchange_manager.is_valid_account:
-                return True
-            exchange_manager.is_valid_account, message = await exchange_manager.exchange_backend.is_valid_account()
-            if not exchange_manager.is_valid_account:
-                exchange_manager.logger.error(
-                    f"Incompatible {exchange_manager.exchange.name.capitalize()} account to use futures trading: "
-                    f"{message}. OctoBot relies on exchanges profits sharing to remain 100% free, please create a "
-                    f"new {exchange_manager.exchange.name.capitalize()} account or register a donation to support "
-                    f"the project. {exchanges.get_partners_explanation_message()}")
-        except trading_backend.TimeSyncError as err:
-            exchanges.log_time_sync_error(exchange_manager.logger, exchange_manager.exchange.name,
-                                          err, "exchange_backend.is_valid_account")
-            exchange_manager.is_valid_account = False
-            exchange_manager.init_error = err
+        initial_is_broker_enabled = exchange_manager.is_broker_enabled
+        try:
+            exchange_manager.is_broker_enabled, _ = await exchange_manager.exchange_backend.is_valid_account()
+            exchange_manager.logger.debug(f"Broker rebate enabled: {exchange_manager.is_broker_enabled}")
         except Exception as err:
-            exchange_manager.is_valid_account = False
-            exchange_manager.init_error = err
-            exchange_manager.logger.exception(err, True, f"Error when loading exchange account: {err}")
-        finally:
-            if exchange_manager.is_valid_account:
-                exchange_manager.logger.info("On behalf of the OctoBot team, thank you for "
-                                             "actively supporting the project !")
+            exchange_manager.is_broker_enabled = initial_is_broker_enabled
+            exchange_manager.logger.debug(f"Error when checking account broker state: {err}")
 
 
 async def _is_supporting_octobot() -> bool:

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/exchange_manager.py

@@ -70,8 +70,7 @@ class ExchangeManager(util.Initializable):
         self.trader = None
         self.exchange = None
         self.exchange_backend = None
-        self.is_valid_account = True
-        self.init_error = None
+        self.is_broker_enabled = False
         self.trading_modes = []
 
         self.exchange_web_socket = None

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/traders/trader.py

@@ -257,7 +257,7 @@ class Trader(util.Initializable):
 
             # get real order from exchange
             updated_order = order_factory.create_order_instance_from_raw(
-                self, created_order, force_open_or_pending_creation=True
+                self, created_order, force_open_or_pending_creation=True, has_just_been_created=True
             )
             is_pending_creation = updated_order.status == enums.OrderStatus.PENDING_CREATION
 

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/types/rest_exchange.py

@@ -447,7 +447,10 @@ class RestExchange(abstract_exchange.AbstractExchange):
         raise NotImplementedError(f"get_account_id is not implemented on {self.exchange_manager.exchange_name}")
 
     async def get_balance(self, **kwargs: dict):
-        return await self.connector.get_balance(**kwargs)
+        try:
+            return await self.connector.get_balance(**kwargs)
+        except ccxt.AuthenticationError as err:
+            raise errors.AuthenticationError(err) from err
 
     async def get_symbol_prices(self, symbol: str, time_frame: commons_enums.TimeFrames, limit: int = None,
                                 **kwargs: dict) -> typing.Optional[list]:

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/exchanges/util/exchange_util.py

@@ -207,6 +207,7 @@ def get_enabled_exchanges(config):
 async def get_local_exchange_manager(
     exchange_name: str, exchange_config: dict, tentacles_setup_config,
     is_sandboxed: bool, ignore_config=False, builder=None, use_cached_markets=True,
+    is_broker_enabled: bool = False,
     market_filter: typing.Union[None, typing.Callable[[dict], bool]] = None
 ):
     exchange_type = exchange_config.get(common_constants.CONFIG_EXCHANGE_TYPE, get_default_exchange_type(exchange_name))
@@ -220,6 +221,7 @@ async def get_local_exchange_manager(
         .is_using_exchange_type(exchange_type) \
         .is_exchange_only() \
         .is_rest_only() \
+        .is_broker_enabled(is_broker_enabled) \
         .use_cached_markets(use_cached_markets) \
         .use_market_filter(market_filter) \
         .is_ignoring_config(ignore_config) \

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/orders/order.py

@@ -58,6 +58,7 @@ class Order(util.Initializable):
         self.side = side
         self.tag = None
         self.associated_entry_ids = None
+        self.broker_applied = False
 
         # original order attributes
         self.creation_time = self.exchange_manager.exchange.get_exchange_current_time()
@@ -282,6 +283,10 @@ class Order(util.Initializable):
         if self.is_created() and not self.is_closed():
             await self.update_order_status()
 
+    def register_broker_applied_if_enabled(self):
+        if not self.simulated and self.trader and self.trader.exchange_manager:
+            self.broker_applied = self.trader.exchange_manager.is_broker_enabled
+
     def _on_origin_price_change(self, previous_price, price_time):
         """
         Called when origin price just changed.
@@ -529,12 +534,14 @@ class Order(util.Initializable):
         except KeyError:
             return False
 
-    def get_computed_fee(self, forced_value=None):
+    def get_computed_fee(self, forced_value=None, use_origin_quantity_and_price=False):
         is_from_exchange = False
+        price = self.origin_price if use_origin_quantity_and_price else self.filled_price
+        quantity = self.origin_quantity if use_origin_quantity_and_price else self.filled_quantity
         if self.fees_currency_side is enums.FeesCurrencySide.UNDEFINED:
-            computed_fee = self.exchange_manager.exchange.get_trade_fee(self.symbol, self.order_type,
-                                                                        self.filled_quantity, self.filled_price,
-                                                                        self.taker_or_maker)
+            computed_fee = self.exchange_manager.exchange.get_trade_fee(
+                self.symbol, self.order_type, quantity, price, self.taker_or_maker
+            )
             value = computed_fee[enums.FeePropertyColumns.COST.value]
             currency = computed_fee[enums.FeePropertyColumns.CURRENCY.value]
             is_from_exchange = computed_fee[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value]
@@ -542,10 +549,10 @@ class Order(util.Initializable):
             symbol_fees = self.exchange_manager.exchange.get_fees(self.symbol)
             fees = decimal.Decimal(f"{symbol_fees[self.taker_or_maker]}")
             if self.fees_currency_side is enums.FeesCurrencySide.CURRENCY:
-                value = self.filled_quantity / self.filled_price * fees
+                value = quantity / price * fees
                 currency = self.currency
             else:
-                value = self.filled_quantity * self.filled_price * fees
+                value = quantity * price * fees
                 currency = self.market
         return {
             enums.FeePropertyColumns.IS_FROM_EXCHANGE.value: is_from_exchange,
@@ -674,6 +681,10 @@ class Order(util.Initializable):
         # rebind order attributes that are not stored on exchange
         order_dict = order_details.get(constants.STORAGE_ORIGIN_VALUE, {})
         self.tag = order_dict.get(enums.ExchangeConstantsOrderColumns.TAG.value, self.tag)
+        self.broker_applied = order_dict.get(
+            enums.ExchangeConstantsOrderColumns.BROKER_APPLIED.value,
+            self.broker_applied
+        )
         self.order_id = order_dict.get(enums.ExchangeConstantsOrderColumns.ID.value, self.order_id)
         self.exchange_order_id = order_dict.get(enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value,
                                                 self.exchange_order_id)
@@ -768,6 +779,7 @@ class Order(util.Initializable):
             enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value: self.reduce_only,
             enums.ExchangeConstantsOrderColumns.TAG.value: self.tag,
             enums.ExchangeConstantsOrderColumns.SELF_MANAGED.value: self.is_self_managed(),
+            enums.ExchangeConstantsOrderColumns.BROKER_APPLIED.value: self.broker_applied,
         }
 
     def clear(self):

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/orders/order_factory.py

@@ -23,9 +23,13 @@ def create_order_from_raw(trader, raw_order):
     return create_order_from_type(trader, order_type)
 
 
-def create_order_instance_from_raw(trader, raw_order, force_open_or_pending_creation=False):
+def create_order_instance_from_raw(
+    trader, raw_order, force_open_or_pending_creation=False, has_just_been_created=False
+):
     order = create_order_from_raw(trader, raw_order)
     order.update_from_raw(raw_order)
+    if has_just_been_created:
+        order.register_broker_applied_if_enabled()
     if force_open_or_pending_creation \
             and order.status not in (enums.OrderStatus.OPEN, enums.OrderStatus.PENDING_CREATION):
         order.status = enums.OrderStatus.OPEN

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/portfolios/channel/balance_updater.py

@@ -57,8 +57,13 @@ class BalanceUpdater(portfolios_channel.BalanceProducer):
                     f"{self.channel.exchange_manager.exchange_name} is not supporting updates"
                 )
                 await self.pause()
+            except errors.AuthenticationError as err:
+                self.logger.exception(
+                    err, True, f"Authentication error when fetching balance: {err}. Retrying in the next update cycle"
+                )
+                await asyncio.sleep(self.BALANCE_REFRESH_TIME)
             except Exception as e:
-                self.logger.error(f"Failed to update balance : {e}")
+                self.logger.exception(e, True, f"Failed to update balance : {e}")
 
     async def fetch_and_push(self):
         await self.push((await self.fetch_portfolio()))

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/portfolios/portfolio.py

@@ -136,7 +136,7 @@ class Portfolio:
         """
         Realize portfolio availability update
         :param order: the order that triggers the portfolio update
-        :param is_new_order: True when the order is being created
+        :param is_new_order: True when the order is being created, False when cancelled
         """
         raise NotImplementedError("update_portfolio_available_from_order is not implemented")
 

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/portfolios/portfolio_manager.py

@@ -266,6 +266,7 @@ class PortfolioManager(util.Initializable):
             if order.is_filled():
                 self.portfolio.update_portfolio_from_filled_order(order)
             else:
+                # order cancelled
                 self.portfolio.update_portfolio_available(order, is_new_order=False)
             return True
         except errors.PortfolioNegativeValueError as portfolio_negative_value_error:

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/portfolios/types/spot_portfolio.py

@@ -17,6 +17,7 @@ import octobot_trading.constants as constants
 import octobot_trading.enums as enums
 import octobot_trading.personal_data.portfolios.assets.spot_asset as spot_asset
 import octobot_trading.personal_data.portfolios.portfolio as portfolio_class
+import octobot_trading.personal_data.orders.order_util as order_util
 
 
 class SpotPortfolio(portfolio_class.Portfolio):
@@ -28,20 +29,23 @@ class SpotPortfolio(portfolio_class.Portfolio):
         Call update_portfolio_data for order currency and market
         :param order: the order that updated the portfolio
         """
-        # update currency
+        base_fees = order.get_total_fees(order.currency)
+        quote_fees = order.get_total_fees(order.market)
+
+        # update base
         if order.side == enums.TradeOrderSide.BUY:
-            new_quantity = order.filled_quantity - order.get_total_fees(order.currency)
+            new_quantity = order.filled_quantity - base_fees
             self._update_portfolio_data(order.currency, total_value=new_quantity, available_value=new_quantity)
         else:
-            new_quantity = -order.filled_quantity
+            new_quantity = -order.filled_quantity - base_fees
             self._update_portfolio_data(order.currency, total_value=new_quantity)
 
-        # update market
+        # update quote
         if order.side == enums.TradeOrderSide.BUY:
-            new_quantity = -(order.filled_quantity * order.filled_price)
+            new_quantity = -(order.filled_quantity * order.filled_price) - quote_fees
             self._update_portfolio_data(order.market, total_value=new_quantity)
         else:
-            new_quantity = (order.filled_quantity * order.filled_price) - order.get_total_fees(order.market)
+            new_quantity = (order.filled_quantity * order.filled_price) - quote_fees
             self._update_portfolio_data(order.market, total_value=new_quantity, available_value=new_quantity)
 
     def update_portfolio_data_from_withdrawal(self, amount, currency):
@@ -56,18 +60,26 @@ class SpotPortfolio(portfolio_class.Portfolio):
         """
         Realise portfolio availability update
         :param order: the order that triggers the portfolio update
-        :param is_new_order: True when the order is being created
+        :param is_new_order: True when the order is being created, False when cancelled
         """
+        multiplier = constants.ONE if is_new_order else -constants.ONE
+
+        # take fees into account when in locked asset
+        # ( a BTC/USDT order with USDT fees need to lock USDT fees to be able to pay them)
+        forecasted_fees = order.get_computed_fee(use_origin_quantity_and_price=not order.is_filled())
+        base_fees = order_util.get_fees_for_currency(forecasted_fees, order.currency)
+        quote_fees = order_util.get_fees_for_currency(forecasted_fees, order.market)
+
         # when buy order
         if order.side == enums.TradeOrderSide.BUY:
-            new_quantity = - order.origin_quantity * order.origin_price * (constants.ONE if is_new_order else -constants.ONE)
+            new_quantity = - (order.origin_quantity * order.origin_price + quote_fees) * multiplier
             self._update_portfolio_data(order.market,
                                         available_value=new_quantity,
                                         total_value=constants.ZERO)
 
         # when sell order
         else:
-            new_quantity = - order.origin_quantity * (constants.ONE if is_new_order else -constants.ONE)
+            new_quantity = - (order.origin_quantity + base_fees) * multiplier
             self._update_portfolio_data(order.currency,
                                         available_value=new_quantity,
                                         total_value=constants.ZERO)

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/personal_data/trades/trade.py

@@ -61,6 +61,7 @@ class Trade:
         self.tag = None
         self.quantity_currency = None
         self.associated_entry_ids = None
+        self.broker_applied = False
 
         # raw exchange trade type, used to create trade dict
         self.exchange_trade_type = None
@@ -94,6 +95,7 @@ class Trade:
         self.reduce_only = order.reduce_only
         self.tag = order.tag
         self.associated_entry_ids = order.associated_entry_ids
+        self.broker_applied = order.broker_applied
 
     def get_time(self):
         return self.executed_time if self.has_been_executed() else self.canceled_time
@@ -125,6 +127,7 @@ class Trade:
             enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value: self.reduce_only,
             enums.ExchangeConstantsOrderColumns.TAG.value: self.tag,
             enums.ExchangeConstantsOrderColumns.ENTRIES.value: self.associated_entry_ids,
+            enums.ExchangeConstantsOrderColumns.BROKER_APPLIED.value: self.broker_applied,
             enums.TradeExtraConstants.CREATION_TIME.value: self.creation_time,
         }
 
@@ -165,6 +168,9 @@ class Trade:
         trade.reduce_only = trade_dict.get(enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value)
         trade.tag = trade_dict.get(enums.ExchangeConstantsOrderColumns.TAG.value)
         trade.associated_entry_ids = trade_dict.get(enums.ExchangeConstantsOrderColumns.ENTRIES.value)
+        trade.broker_applied = trade_dict.get(
+            enums.ExchangeConstantsOrderColumns.BROKER_APPLIED.value, trade.broker_applied
+        )
         trade.creation_time = trade_dict.get(enums.TradeExtraConstants.CREATION_TIME.value)
         return trade
 

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/octobot_trading/util/test_tools/exchange_data.py

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

{OctoBot-Trading-2.4.51 → OctoBot-Trading-2.4.53}/tests/personal_data/orders/__init__.py

@@ -41,6 +41,7 @@ async def order_simulator(trader_simulator):
 def created_order(order_type, order_type_enum, *args, **kwargs):
     order = order_type(*args, **kwargs)
     order.order_type = order_type_enum
+    order.symbol = "BTC/USDT"
     return order