OctoBot-Trading 2.4.167__tar.gz → 2.4.169__tar.gz

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.169] - 2025-04-11
+### Fixed
+[Subportfolio] handle fees hedge cases for filled oreders deltas 
+
+## [2.4.168] - 2025-04-01
+### Updated
+[Subportfolio] handle locked funds from open orders
+
 ## [2.4.167] - 2025-03-31
 ### Updated
 [Orders] fixed maker/taker fees of chained orders

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -415,6 +415,7 @@ tests/personal_data/portfolios/test_portfolio_manager.py
 tests/personal_data/portfolios/test_portfolio_profitability.py
 tests/personal_data/portfolios/test_portfolio_util.py
 tests/personal_data/portfolios/test_portfolio_value_holder.py
+tests/personal_data/portfolios/test_sub_portfolio_data.py
 tests/personal_data/portfolios/test_value_converter.py
 tests/personal_data/portfolios/assets/__init__.py
 tests/personal_data/portfolios/assets/test_future_asset.py

{OctoBot-Trading-2.4.167/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.169}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/api/__init__.py

@@ -196,6 +196,7 @@ from octobot_trading.api.orders import (
     get_order_profitability,
     get_minimal_order_cost,
     get_order_trailing_profile_dict,
+    get_orders_locked_amounts_by_asset,
     create_order,
     cancel_all_open_orders,
     cancel_all_open_orders_with_currency,
@@ -385,6 +386,7 @@ __all__ = [
     "get_order_profitability",
     "get_minimal_order_cost",
     "get_order_trailing_profile_dict",
+    "get_orders_locked_amounts_by_asset",
     "create_order",
     "cancel_all_open_orders",
     "cancel_all_open_orders_with_currency",

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/api/orders.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.personal_data as personal_data
@@ -100,3 +102,7 @@ def get_minimal_order_cost(exchange_manager, symbol, default_price=None) -> floa
 
 def get_order_trailing_profile_dict(order: personal_data.Order) -> dict:
     return storage.get_order_trailing_profile_dict(order)
+
+
+def get_orders_locked_amounts_by_asset(open_orders: list[personal_data.Order]) -> dict[str, decimal.Decimal]:
+    return personal_data.get_orders_locked_amounts_by_asset(open_orders)

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/exchanges/util/exchange_util.py

@@ -399,7 +399,7 @@ def update_raw_order_from_raw_trade(order_to_update, raw_trade):
         enums.ExchangeConstantsOrderColumns.PRICE.value)
     order_to_update[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value] = order_to_update.get(
         enums.ExchangeConstantsOrderColumns.TIMESTAMP.value,
-        raw_trade[enums.ExchangeConstantsOrderColumns.TIMESTAMP.value])
+        raw_trade.get(enums.ExchangeConstantsOrderColumns.TIMESTAMP.value))
     order_to_update[enums.ExchangeConstantsOrderColumns.STATUS.value] = enums.OrderStatus.FILLED.value
     order_to_update[enums.ExchangeConstantsOrderColumns.FILLED.value] = raw_trade.get(
         enums.ExchangeConstantsOrderColumns.AMOUNT.value)
@@ -409,6 +409,12 @@ def update_raw_order_from_raw_trade(order_to_update, raw_trade):
     order_to_update[
         enums.ExchangeConstantsOrderColumns.FEE.value
     ] = raw_trade.get(enums.ExchangeConstantsOrderColumns.FEE.value)
+    order_to_update[
+        enums.ExchangeConstantsOrderColumns.TAG.value
+    ] = raw_trade.get(enums.ExchangeConstantsOrderColumns.TAG.value)
+    order_to_update[
+        enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value
+    ] = raw_trade.get(enums.ExchangeConstantsOrderColumns.REDUCE_ONLY.value, False)
     return order_to_update
 
 

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/__init__.py

@@ -34,6 +34,8 @@ from octobot_trading.personal_data.orders import (
     total_fees_from_order_dict,
     get_locked_funds,
     get_fees_for_currency,
+    get_order_locked_amount,
+    get_orders_locked_amounts_by_asset,
     parse_raw_fees,
     parse_order_status,
     parse_is_cancelled,
@@ -270,6 +272,8 @@ __all__ = [
     "total_fees_from_order_dict",
     "get_locked_funds",
     "get_fees_for_currency",
+    "get_order_locked_amount",
+    "get_orders_locked_amounts_by_asset",
     "parse_raw_fees",
     "parse_order_status",
     "parse_is_cancelled",

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/orders/__init__.py

@@ -94,6 +94,8 @@ from octobot_trading.personal_data.orders.order_util import (
     get_locked_funds,
     total_fees_from_order_dict,
     get_fees_for_currency,
+    get_order_locked_amount,
+    get_orders_locked_amounts_by_asset,
     parse_raw_fees,
     parse_order_status,
     parse_is_cancelled,
@@ -170,6 +172,8 @@ __all__ = [
     "get_locked_funds",
     "total_fees_from_order_dict",
     "get_fees_for_currency",
+    "get_order_locked_amount",
+    "get_orders_locked_amounts_by_asset",
     "parse_raw_fees",
     "parse_order_status",
     "parse_is_cancelled",

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/orders/order_util.py

@@ -29,6 +29,7 @@ import octobot_trading.errors as errors
 import octobot_trading.personal_data.orders.decimal_order_adapter as decimal_order_adapter
 import octobot_trading.exchanges.util.exchange_market_status_fixer as exchange_market_status_fixer
 import octobot_trading.personal_data.orders.states.fill_order_state as fill_order_state
+import octobot_trading.personal_data.orders.order as order_import
 from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 
 
@@ -376,6 +377,42 @@ def get_fees_for_currency(fee, currency):
     return constants.ZERO
 
 
+def get_order_locked_amount(order: order_import.Order) -> decimal.Decimal:
+    # 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, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
+    # when buy order
+    if order.side == enums.TradeOrderSide.BUY:
+        return order.origin_quantity * order.origin_price + get_fees_for_currency(forecasted_fees, quote)
+    # when sell order
+    return order.origin_quantity + get_fees_for_currency(forecasted_fees, base)
+
+
+def get_orders_locked_amounts_by_asset(open_orders: list[order_import.Order]) -> dict[str, decimal.Decimal]:
+    if not open_orders:
+        return {}
+    locked_funds_by_asset = {}
+    for order in open_orders:
+        base, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
+        # use get_order_locked_amount just like trader simulator to ensure locked funds integrity
+        if order.side == enums.TradeOrderSide.BUY:
+            # buy orders only lock fees in quote
+            locked_quote = get_order_locked_amount(order)
+            if quote not in locked_funds_by_asset:
+                locked_funds_by_asset[quote] = locked_quote
+            else:
+                locked_funds_by_asset[quote] += locked_quote
+        else:
+            # sell orders only lock fees in base
+            locked_base = get_order_locked_amount(order)
+            if base not in locked_funds_by_asset:
+                locked_funds_by_asset[base] = locked_base
+            else:
+                locked_funds_by_asset[base] += locked_base
+    return locked_funds_by_asset
+
+
 def parse_raw_fees(raw_fees):
     fees = raw_fees
     if fees:

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -20,6 +20,7 @@ import typing
 import octobot_trading.personal_data.portfolios.asset as asset
 import octobot_trading.personal_data.portfolios.assets
 import octobot_trading.personal_data.orders.order as order_import
+import octobot_trading.personal_data.orders.order_util as order_util
 import octobot_trading.personal_data.portfolios.sub_portfolio_data as sub_portfolio_data
 import octobot_trading.constants as constants
 import octobot_trading.enums as enums
@@ -281,11 +282,12 @@ def _resolve_sub_portfolio(
     resolved_content = {}
     funds_deltas = {}
     missing_funds = {}
-    forecasted_sub_portfolio_content = sub_portfolio.get_content_after_deltas()
     missing_amount_by_asset = {}
+    forecasted_sub_portfolio_content = sub_portfolio.get_content_after_deltas()
     for asset_name, holdings in forecasted_sub_portfolio_content.items():
         missing_amount_in_asset = _resolve_sub_portfolio_asset(
-            asset_name, holdings, remaining_master_portfolio, resolved_content, forbidden_filling_assets
+            asset_name, holdings, remaining_master_portfolio, resolved_content,
+            sub_portfolio.locked_funds_by_asset.get(asset_name, constants.ZERO), forbidden_filling_assets
         )
         if missing_amount_in_asset > constants.ZERO:
             missing_amount_by_asset[asset_name] = missing_amount_in_asset
@@ -309,47 +311,80 @@ def _resolve_sub_portfolio(
 
 
 def _resolve_sub_portfolio_asset(
-    asset_name, holdings, remaining_master_portfolio, resolved_content, forbidden_filling_assets
+    asset_name: str,
+    holdings: dict[str, decimal.Decimal],
+    remaining_master_portfolio: sub_portfolio_data.SubPortfolioData,
+    resolved_content: dict[str, dict[str, decimal.Decimal]],
+    locked_funds: decimal.Decimal,
+    forbidden_filling_assets: list[str]
 ) -> decimal.Decimal:
-    required_amount = holdings[commons_constants.PORTFOLIO_TOTAL]
+    required_total_amount = holdings[commons_constants.PORTFOLIO_TOTAL]
+    required_available_amount = holdings[commons_constants.PORTFOLIO_TOTAL] - locked_funds
     missing_amount_in_asset = constants.ZERO
     if asset_name in remaining_master_portfolio.content and asset_name not in forbidden_filling_assets:
         remaining_master_holding = remaining_master_portfolio.content[asset_name]
-        # for now only handle available value (ignore funds in orders)
+        # available = total - locked_funds
+        remaining_total = remaining_master_holding[commons_constants.PORTFOLIO_TOTAL]
         remaining_available = remaining_master_holding[commons_constants.PORTFOLIO_AVAILABLE]
-        if remaining_available >= required_amount * (constants.ONE - constants.SUB_PORTFOLIO_ALLOWED_MISSING_RATIO):
-            sub_portfolio_amount = min(remaining_available, required_amount)
+        allowed_missing_ratio_multiplier = constants.ONE - constants.SUB_PORTFOLIO_ALLOWED_MISSING_RATIO
+        if remaining_total < locked_funds * allowed_missing_ratio_multiplier:
+            # should never happen, log it in case it does
+            commons_logging.get_logger(__name__).error(
+                f"Unexpected missing locked {asset_name} funds in total portfolio {remaining_total=} {locked_funds=}"
+            )
+        # As orders are still open, their funds must be locked. Therefore, only consider available funds
+        if remaining_available >= required_available_amount * allowed_missing_ratio_multiplier:
+            if remaining_total < required_total_amount * allowed_missing_ratio_multiplier:
+                # should never happen, log it in case it does
+                commons_logging.get_logger(__name__).error(
+                    f"Unexpected missing total {asset_name} value in portfolio: ensure order funds really locked"
+                )
+            sub_portfolio_total_amount = min(remaining_total, required_total_amount)
+            # Do not use remaining_available or remaining_available here to avoid side effects due to locked fees
+            # on some exchanges and not on others. Only compute from total holdings.
+            # ex: coinbase locks 101 USDC to buy for 100 USDC + 1 USDC fee,
+            # binance will just lock 100 and given less of the bought asset
+            sub_portfolio_available_amount = sub_portfolio_total_amount - locked_funds
             # assets are available in master portfolio: reduce it from master
             if asset_name in resolved_content:
-                resolved_content[asset_name][commons_constants.PORTFOLIO_TOTAL] += sub_portfolio_amount
-                resolved_content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] += sub_portfolio_amount
+                resolved_content[asset_name][commons_constants.PORTFOLIO_TOTAL] += sub_portfolio_total_amount
+                resolved_content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] += sub_portfolio_available_amount
             else:
                 resolved_content[asset_name] = {
-                    commons_constants.PORTFOLIO_TOTAL: sub_portfolio_amount,
-                    commons_constants.PORTFOLIO_AVAILABLE: sub_portfolio_amount,
+                    commons_constants.PORTFOLIO_TOTAL: sub_portfolio_total_amount,
+                    commons_constants.PORTFOLIO_AVAILABLE: sub_portfolio_available_amount,
                 }
-            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_TOTAL] -= sub_portfolio_amount
-            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] -= sub_portfolio_amount
+            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_TOTAL] -= sub_portfolio_total_amount
+            # don't make remaining available negative
+            removed_portfolio_available_amount = min(remaining_available, sub_portfolio_available_amount)
+            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] -= removed_portfolio_available_amount
         else:
-            # not enough assets in master portfolio
+            # As orders are still open, their funds must be locked. Therefore, only consider available funds
+            # Not enough assets in master portfolio
+            usable_total = min(remaining_total, remaining_available + locked_funds)
             if asset_name in resolved_content:
-                resolved_content[asset_name][commons_constants.PORTFOLIO_TOTAL] += remaining_available
+                resolved_content[asset_name][commons_constants.PORTFOLIO_TOTAL] += usable_total
                 resolved_content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] += remaining_available
             else:
                 resolved_content[asset_name] = {
-                    commons_constants.PORTFOLIO_TOTAL: remaining_available,
+                    commons_constants.PORTFOLIO_TOTAL: usable_total,
                     commons_constants.PORTFOLIO_AVAILABLE: remaining_available,
                 }
-            missing_amount_in_asset = abs(remaining_available - required_amount)
-            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_TOTAL] -= remaining_available
+            missing_amount_in_asset = abs(remaining_available - required_available_amount)
+            remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_TOTAL] -= usable_total
             remaining_master_portfolio.content[asset_name][commons_constants.PORTFOLIO_AVAILABLE] -= remaining_available
     else:
+        if locked_funds > constants.ZERO:
+            # should never happen, log it in case it does
+            commons_logging.get_logger(__name__).error(
+                f"Unexpected missing {asset_name} value in portfolio but {locked_funds=}"
+            )
         resolved_content[asset_name] = {
             commons_constants.PORTFOLIO_TOTAL: constants.ZERO,
             commons_constants.PORTFOLIO_AVAILABLE: constants.ZERO,
         }
         # asset not in master portfolio (anymore):
-        missing_amount_in_asset = required_amount
+        missing_amount_in_asset = required_available_amount
     return missing_amount_in_asset
 
 
@@ -392,7 +427,8 @@ def _fill_missing_assets_from_allowed_filling_assets(
             if filling_asset in funds_deltas:
                 funds_deltas[filling_asset][commons_constants.PORTFOLIO_TOTAL] += funds_to_add_in_filling_asset
                 funds_deltas[filling_asset][commons_constants.PORTFOLIO_AVAILABLE] += funds_to_add_in_filling_asset
-            else:
+            elif funds_to_add_in_filling_asset != constants.ZERO:
+                # only add delta when delta is not 0
                 funds_deltas[filling_asset] = {
                     commons_constants.PORTFOLIO_TOTAL: funds_to_add_in_filling_asset,
                     commons_constants.PORTFOLIO_AVAILABLE: funds_to_add_in_filling_asset
@@ -438,7 +474,7 @@ def get_portfolio_filled_orders_deltas(
     updated_portfolio_content: dict[str, dict[str, decimal.Decimal]],
     filled_orders: list[order_import.Order]
 ) -> (dict[str, dict[str, decimal.Decimal]], dict[str, dict[str, decimal.Decimal]]):
-    orders_asset_deltas = _get_assets_delta_from_orders(filled_orders)
+    orders_asset_deltas, possible_fees_asset_deltas = _get_assets_delta_from_orders(filled_orders)
     portfolios_asset_deltas = _get_assets_delta_from_portfolio(previous_portfolio_content, updated_portfolio_content)
     # return portfolio asset deltas that can approximately be explained by given orders
     orders_linked_deltas = {}
@@ -467,13 +503,26 @@ def get_portfolio_filled_orders_deltas(
             # similar delta (+/- fees)
             # this delta is due to these orders: add it
             orders_linked_deltas[asset_name] = holdings_delta
+        elif (
+            # try while taking possible fees into account
+            # approx same value
+            asset_name in possible_fees_asset_deltas and (
+                abs(min_allowed_equivalent_total_holding)
+                < abs(order_asset_delta + possible_fees_asset_deltas[asset_name])
+                < abs(max_allowed_equivalent_total_holding)
+            )
+        ):
+            # similar delta considering fees
+            # this delta is due to these orders: add it
+            orders_linked_deltas[asset_name] = holdings_delta
         elif abs(order_asset_delta) > abs(max_allowed_equivalent_total_holding):
-            # too little in portfolio delta to be from those orders: add it to ignored_deltas: there should be
-            # something in delta but there is not, this is unexpected
+            # too little in portfolio delta to be from those orders
+            # As potential fees have already been taken into account, THIS IS UNEXPECTED.
+            # Add it to ignored_deltas
             ignored_deltas[asset_name] = holdings_delta
         elif abs(min_allowed_equivalent_total_holding) > abs(order_asset_delta):
             # too much in portfolio delta: only take what is linked to the orders deltas
-            # todo: handle available assets when taking open orders into account (now set both available and total)
+            # => updates both total and available
             orders_linked_deltas[asset_name] = {
                 key: order_asset_delta
                 for key in holdings_delta
@@ -511,10 +560,14 @@ def _get_assets_delta_from_portfolio(
 
 
 
-def _get_assets_delta_from_orders(orders: list[order_import.Order]) -> dict[str, decimal.Decimal]:
+def _get_assets_delta_from_orders(orders: list[order_import.Order]) -> (
+    dict[str, decimal.Decimal], dict[str, decimal.Decimal]
+):
     asset_deltas = {}
+    possible_fee_related_deltas = {}
     for order in orders:
         base, quote = symbol_util.parse_symbol(order.symbol).base_and_quote()
+        # order "expected" related deltas
         added_unit_and_amount = (
             (base, order.origin_quantity)
             if order.side is enums.TradeOrderSide.BUY else (quote, order.total_cost)
@@ -531,4 +584,12 @@ def _get_assets_delta_from_orders(orders: list[order_import.Order]) -> dict[str,
                 asset_deltas[unit_and_amount[0]] = unit_and_amount[1] * multiplier
             else:
                 asset_deltas[unit_and_amount[0]] += unit_and_amount[1] * multiplier
-    return asset_deltas
+        # order "probable" related deltas (account for worse case fees)
+        forecasted_fees = order.get_computed_fee(use_origin_quantity_and_price=True)
+        for fee_asset in (base, quote):
+            if asset_amount := order_util.get_fees_for_currency(forecasted_fees, fee_asset):
+                if fee_asset not in possible_fee_related_deltas:
+                    possible_fee_related_deltas[fee_asset] = -asset_amount
+                else:
+                    possible_fee_related_deltas[fee_asset] += -asset_amount
+    return asset_deltas, possible_fee_related_deltas

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/portfolios/sub_portfolio_data.py

@@ -18,8 +18,10 @@ import dataclasses
 import decimal
 import typing
 
+import octobot_commons.logging as commons_logging
 import octobot_commons.constants as commons_constants
 import octobot_trading.personal_data as personal_data
+import octobot_trading.constants as constants
 
 
 @dataclasses.dataclass
@@ -31,10 +33,17 @@ class SubPortfolioData:
     unit: typing.Optional[str]
     # deltas to be applied on top of the current content of the sub-portfolio from get_content_after_deltas()
     funds_deltas: dict[str, dict[str, decimal.Decimal]] = dataclasses.field(default_factory=dict)
+    # funds that are missing from this portfolio. Populated after portfolio has been resolved
     missing_funds: dict[str, decimal.Decimal] = dataclasses.field(default_factory=dict)
 
+    # funds that are locked (maybe in orders) from this portfolio
+    locked_funds_by_asset: dict[str, decimal.Decimal] = dataclasses.field(default_factory=dict)
+
 
     def get_content_after_deltas(self) -> dict[str, dict[str, decimal.Decimal]]:
+        """
+        Computes the updated portfolio from delta available and total
+        """
         updated_content = copy.deepcopy(self.content)
         for asset, delta_values in self.funds_deltas.items():
             if asset in updated_content:
@@ -51,6 +60,29 @@ class SubPortfolioData:
                 }
         return updated_content
 
+    def get_content_from_total_deltas_and_locked_funds(self) -> dict[str, dict[str, decimal.Decimal]]:
+        """
+        Only uses PORTFOLIO_TOTAL deltas and computes available values from locked_funds_by_asset
+        """
+        updated_content = copy.deepcopy(self.content)
+        for asset, delta_values in self.funds_deltas.items():
+            if asset in updated_content:
+                updated_content[asset][commons_constants.PORTFOLIO_TOTAL] += (
+                    delta_values[commons_constants.PORTFOLIO_TOTAL]
+                )
+            else:
+                updated_content[asset] = {
+                    commons_constants.PORTFOLIO_TOTAL: delta_values[commons_constants.PORTFOLIO_TOTAL]
+                }
+        for asset, values in updated_content.items():
+            locked_funds = self.locked_funds_by_asset.get(asset, constants.ZERO)
+            if locked_funds > values[commons_constants.PORTFOLIO_TOTAL]:
+                commons_logging.get_logger(__name__).error(
+                    f"Unexpected: negative {asset} available value after applying {locked_funds} locked funds to {values}"
+                )
+            values[commons_constants.PORTFOLIO_AVAILABLE] = values[commons_constants.PORTFOLIO_TOTAL] - locked_funds
+        return updated_content
+
     def is_similar_to(self, other) -> bool:
         return (
             other

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/octobot_trading/personal_data/portfolios/types/spot_portfolio.py

@@ -71,22 +71,16 @@ class SpotPortfolio(portfolio_class.Portfolio):
         """
         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 + quote_fees) * multiplier
+            new_quantity = - order_util.get_order_locked_amount(order) * multiplier
             self._update_portfolio_data(order.market,
                                         available_value=new_quantity,
                                         total_value=constants.ZERO)
 
         # when sell order
         else:
-            new_quantity = - (order.origin_quantity + base_fees) * multiplier
+            new_quantity = - order_util.get_order_locked_amount(order) * multiplier
             self._update_portfolio_data(order.currency,
                                         available_value=new_quantity,
                                         total_value=constants.ZERO)

{OctoBot-Trading-2.4.167 → OctoBot-Trading-2.4.169}/tests/exchanges/util/test_exchange_util.py

@@ -19,7 +19,7 @@ import mock
 import trading_backend.exchanges
 import octobot_commons.constants as commons_constants
 import octobot_commons.configuration as commons_configuration
-import octobot_trading.constants as constants
+import octobot_trading.enums as enums
 import octobot_trading.exchanges as exchanges
 import octobot_trading.exchanges.util.exchange_util as exchange_util
 
@@ -251,3 +251,44 @@ def test_is_error_on_this_type():
     assert exchange_util.is_error_on_this_type(Exception("api key doesn't exist"), errors) is True
     assert exchange_util.is_error_on_this_type(Exception("api"), errors) is False
     assert exchange_util.is_error_on_this_type(Exception("api"), errors) is False
+
+
+def test_update_raw_order_from_raw_trade():
+    required_keys = [
+        enums.ExchangeConstantsOrderColumns.INFO,
+        enums.ExchangeConstantsOrderColumns.EXCHANGE_ID,
+        enums.ExchangeConstantsOrderColumns.SYMBOL,
+        enums.ExchangeConstantsOrderColumns.TYPE,
+        enums.ExchangeConstantsOrderColumns.AMOUNT,
+        enums.ExchangeConstantsOrderColumns.DATETIME,
+        enums.ExchangeConstantsOrderColumns.SIDE,
+        enums.ExchangeConstantsOrderColumns.TAKER_OR_MAKER,
+        enums.ExchangeConstantsOrderColumns.PRICE,
+        enums.ExchangeConstantsOrderColumns.TIMESTAMP,
+        enums.ExchangeConstantsOrderColumns.STATUS,
+        enums.ExchangeConstantsOrderColumns.FILLED,
+        enums.ExchangeConstantsOrderColumns.COST,
+        enums.ExchangeConstantsOrderColumns.REMAINING,
+        enums.ExchangeConstantsOrderColumns.FEE,
+        enums.ExchangeConstantsOrderColumns.TAG,
+        enums.ExchangeConstantsOrderColumns.REDUCE_ONLY,
+    ]
+    default_value = exchange_util.update_raw_order_from_raw_trade({}, {})
+    assert all(key.value in default_value for key in required_keys)
+    with_trade_values = exchange_util.update_raw_order_from_raw_trade(
+        {}, {**{k.value: k.name for k in required_keys}, **{
+            enums.ExchangeConstantsOrderColumns.ORDER.value: "EXCHANGE_ID",
+            enums.ExchangeConstantsOrderColumns.AMOUNT.value: "AMOUNT",
+        }}
+    )
+    for key in required_keys:
+        if key == enums.ExchangeConstantsOrderColumns.STATUS:
+            assert with_trade_values[key.value] == enums.OrderStatus.FILLED.value
+        elif key == enums.ExchangeConstantsOrderColumns.REMAINING:
+            assert with_trade_values[key.value] == 0
+        elif key == enums.ExchangeConstantsOrderColumns.FILLED:
+            assert with_trade_values[key.value] == "AMOUNT"
+        elif key == enums.ExchangeConstantsOrderColumns.EXCHANGE_ID:
+            assert with_trade_values[key.value] == "EXCHANGE_ID"
+        else:
+            assert with_trade_values[key.value] == key.name