OctoBot-Trading 2.4.174__tar.gz → 2.4.176__tar.gz

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/CHANGELOG.md

@@ -4,9 +4,24 @@ 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.176] - 2025-05-20
+### Added
+[Orders] custom volume in get_valid_split_orders
+[Exchanges] add hyperliquid
+### Updated
+[Exchange] warn on expected error in load markets
+[Orders] ensure created order amount is always set
+### Fixed
+[Portfolio] fix < 0 sub portfolio issue
+[Positions] fix position reversing order and pnl
+
+## [2.4.175] - 2025-05-13
+### Fixed
+[Portfolio] fix different fees discount
+
 ## [2.4.174] - 2025-05-13
 ### Fixed
-[Portfolio] handle portfolia deltas hedge cases
+[Portfolio] handle portfolio deltas hedge cases
 
 ## [2.4.173] - 2025-04-24
 ### Fixed

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/constants.py

@@ -136,6 +136,7 @@ TESTED_EXCHANGES = [
     "coinbase",
     "cryptocom",
     "htx",
+    "hyperliquid",
     "bitget",
     "gateio",
     "ascendex",

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -177,8 +177,13 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                     raise ccxt.AuthenticationError(
                         f"Invalid key format ({html_util.get_html_summary_if_relevant(err)})"
                     ) from err
-                # should never happen: if it does, propagate it
-                self.logger.error(f"Unexpected error when loading markets: {err} ({err.__class__.__name__})")
+                # should not happen: if it does, propagate it
+                if self.exchange_manager.exchange.CAN_MAKE_AUTHENTICATED_REQUESTS_WHEN_LOADING_MARKETS:
+                    # can happen, just warn
+                    self.logger.warning(f"{err.__class__.__name__} when loading markets: {err}")
+                else:
+                    # unexpected: notify
+                    self.logger.error(f"Unexpected error when loading markets: {err} ({err.__class__.__name__})")
                 raise
             except ccxt.ExchangeNotAvailable as err:
                 raise octobot_trading.errors.FailedRequest(

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/exchanges/exchange_factory.py

@@ -67,7 +67,7 @@ async def create_real_exchange(exchange_manager, exchange_config_by_exchange: ty
             or exchange_manager.disable_unauth_retry
         ):
             # auth is required or already retried, don't loop
-            exchange_manager.logger.error(
+            exchange_manager.logger.warning(
                 f"Authentication is required and raised an error: impossible to connect to "
                 f"{exchange_manager.exchange_name} exchange: {err}"
             )

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/exchanges/types/rest_exchange.py

@@ -72,6 +72,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     EXPECT_POSSIBLE_ORDER_NOT_FOUND_DURING_ORDER_CREATION = False  # set True when get_order() can return None
     # (order not found) when orders are being created on exchange and are not fully processed on the exchange side.
     REQUIRES_AUTHENTICATION = False  # set True when even normally public apis require authentication
+    # set True when even loading markets can make auth calls when creds are set
+    CAN_MAKE_AUTHENTICATED_REQUESTS_WHEN_LOADING_MARKETS = False
     HAS_FETCHED_DETAILS = False  # set True when this exchange details (urls etc) have to be fetched before
     # starting the exchange
     IS_SKIPPING_EMPTY_CANDLES_IN_OHLCV_FETCH = False    # set True when the exchange is known for not returning any
@@ -204,7 +206,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
                     stop_price=stop_price, side=side, current_price=current_price,
                     reduce_only=reduce_only, params=params)
                 self.logger.debug(f"Created order: {created_order}")
-                return await self._verify_order(created_order, order_type, symbol, price, side)
+                return await self._verify_order(created_order, order_type, symbol, price, quantity, side)
         return None
 
     async def edit_order(self, exchange_order_id: str, order_type: enums.TraderOrderType, symbol: str,
@@ -225,7 +227,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
             edited_order = await self._edit_order(exchange_order_id, order_type, symbol, quantity=float_quantity,
                                                   price=float_price, stop_price=float_stop_price, side=side,
                                                   current_price=float_current_price, params=params)
-            order = await self._verify_order(edited_order, order_type, symbol, price, side)
+            order = await self._verify_order(edited_order, order_type, symbol, price, quantity, side)
             return order
         return None
 
@@ -310,7 +312,7 @@ class RestExchange(abstract_exchange.AbstractExchange):
                 f"Unexpected error during order operation: {html_util.get_html_summary_if_relevant(e)}"
             )
 
-    async def _verify_order(self, created_order, order_type, symbol, price, side, get_order_params=None):
+    async def _verify_order(self, created_order, order_type, symbol, price, quantity, side, get_order_params=None):
         # some exchanges are not returning the full order details on creation: fetch it if necessary
         if created_order and not self._ensure_order_details_completeness(created_order):
             if ecoc.EXCHANGE_ID.value in created_order:
@@ -332,9 +334,13 @@ class RestExchange(abstract_exchange.AbstractExchange):
                 else:
                     created_order = fetched_order
 
-        # on some exchange, market order are not including price, add it manually to ensure uniformity
-        if created_order is not None and created_order[ecoc.PRICE.value] is None and price is not None:
-            created_order[ecoc.PRICE.value] = float(price)
+        if created_order is not None:
+            # on some exchange, market order are not including price, add it manually to ensure uniformity
+            if created_order[ecoc.PRICE.value] is None and price is not None:
+                created_order[ecoc.PRICE.value] = float(price)
+            # sometimes, amount is 0, this is impossible. If it is, restore amount
+            if not created_order[ecoc.AMOUNT.value] and quantity is not None:
+                created_order[ecoc.AMOUNT.value] = float(quantity)
 
         return created_order
 

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/personal_data/orders/order_util.py

@@ -18,6 +18,7 @@ import asyncio
 import decimal
 import contextlib
 import uuid
+import typing
 
 import octobot_commons.symbols as symbol_util
 import octobot_commons.constants as commons_constants
@@ -109,8 +110,14 @@ def check_cost(total_order_price, min_cost):
 
 
 def get_valid_split_orders(
-    quantity: decimal.Decimal, prices: list[decimal.Decimal], symbol_market
+    quantity: decimal.Decimal, prices: list[decimal.Decimal], symbol_market,
+    amount_ratio_per_order: typing.Optional[list[decimal.Decimal]] = None
 ) -> (list[decimal.Decimal], list[decimal.Decimal]):
+    if amount_ratio_per_order:
+        if len(amount_ratio_per_order) != len(prices):
+            raise ValueError(f"amount_ratio_per_order must have {len(prices)} elements")
+        if any(amount_ratio <= constants.ZERO for amount_ratio in amount_ratio_per_order):
+            raise ValueError(f"all amount_ratio_per_order must by > {constants.ZERO}")
     if len(prices) < 1:
         return [], []
     if len(prices) < 2:
@@ -125,17 +132,23 @@ def get_valid_split_orders(
     # try to split quantity evenly amount prices
     current_supported_orders_count = decimal.Decimal(str(len(prices)))
     while current_supported_orders_count > constants.ONE:
-        order_vol = quantity / current_supported_orders_count
+        if amount_ratio_per_order:
+            used_amount_ratio_per_order = amount_ratio_per_order[:int(current_supported_orders_count)]
+            total_ratios = sum(used_amount_ratio_per_order)
+            candidate_volumes = [
+                quantity * ratio_per_order / total_ratios
+                for ratio_per_order in used_amount_ratio_per_order
+            ]
+        else:
+            candidate_volumes = [quantity / current_supported_orders_count] * int(current_supported_orders_count)
         candidate_prices = prices[:int(current_supported_orders_count)]
-        first_price = min(candidate_prices)
-        last_price = max(candidate_prices)
-        if _are_orders_too_small(min_quantity, min_cost, min_price, first_price, order_vol):
+        if _are_orders_too_small(min_quantity, min_cost, min_price, min(candidate_prices), min(candidate_volumes)):
             # reduce orders count to increase quantity
             current_supported_orders_count -= 1
-        elif _are_orders_too_large(max_quantity, max_cost, max_price, last_price, order_vol):
-            raise errors.InvalidArgumentError(f"Order volume ({order_vol}) is too large")
+        elif _are_orders_too_large(max_quantity, max_cost, max_price, max(candidate_prices), max(candidate_volumes)):
+            raise errors.InvalidArgumentError(f"Order volume ({max(candidate_volumes)}) is too large")
         else:
-            return [order_vol] * int(current_supported_orders_count), candidate_prices
+            return candidate_volumes, candidate_prices
     # default to full quantity and first price
     return [quantity], [prices[0]]
 
@@ -298,24 +311,35 @@ def get_futures_max_order_size(exchange_manager, symbol, side, current_price, re
 
     contract_current_symbol_holding = current_symbol_holding
     contract_market_quantity = market_quantity
+    added_quantity_from_reverse = constants.ZERO
+    might_reverse_position = False
     if current_position.symbol_contract.is_inverse_contract():
         # use USD (in BTC/USD) for order sizes on inverse, convert BTC values into USD ones
         contract_current_symbol_holding = current_symbol_holding * current_price
         contract_market_quantity = market_quantity * current_price
     if side is enums.TradeOrderSide.SELL and current_position.is_long():
         # can also sell the position size in long
-        contract_current_symbol_holding = current_position.size if reduce_only \
-            else contract_current_symbol_holding + current_position.size
+        contract_current_symbol_holding = current_position.size
+        might_reverse_position = not reduce_only
+        added_quantity_from_reverse = current_position.initial_margin
     elif side is enums.TradeOrderSide.BUY and current_position.is_short():
         # can also buy the position size in short
-        contract_market_quantity = abs(current_position.size) if reduce_only \
-            else contract_market_quantity + abs(current_position.size)
-    if (new_position_side is enums.PositionSide.LONG and side is enums.TradeOrderSide.BUY) \
-            or (new_position_side is enums.PositionSide.SHORT and
-                side is enums.TradeOrderSide.SELL):
+        contract_market_quantity = abs(current_position.size)
+        might_reverse_position = not reduce_only
+        added_quantity_from_reverse = current_position.initial_margin
+    max_reducing_position_order_size = (
+        contract_market_quantity if side is enums.TradeOrderSide.BUY else contract_current_symbol_holding
+    )
+    if (
+        (new_position_side is enums.PositionSide.LONG and side is enums.TradeOrderSide.BUY)
+        or (new_position_side is enums.PositionSide.SHORT and  side is enums.TradeOrderSide.SELL)
+        or might_reverse_position
+    ):
         quantity = market_quantity if current_position.symbol_contract.is_inverse_contract() \
             else market_quantity * current_price
-        unleveraged_quantity = quantity / current_position.symbol_contract.current_leverage
+        # include added_quantity_from_reverse in case funds get freed from reversing a position
+        usable_quantity = quantity + added_quantity_from_reverse
+        unleveraged_quantity = usable_quantity / current_position.symbol_contract.current_leverage
         max_position_increased_order_quantity = get_max_order_quantity_for_price(
             current_position, unleveraged_quantity, current_price, new_position_side, symbol
         )
@@ -326,8 +350,11 @@ def get_futures_max_order_size(exchange_manager, symbol, side, current_price, re
             max_position_increased_order_quantity *= \
                 exchange_manager.exchange.MAX_INCREASED_POSITION_QUANTITY_MULTIPLIER
         # increasing position: always use the same currency
-        return max_position_increased_order_quantity, True
-    return contract_market_quantity if side is enums.TradeOrderSide.BUY else contract_current_symbol_holding, False
+        return max_position_increased_order_quantity + (
+            # include reducing position amount to process reverse
+            max_reducing_position_order_size if might_reverse_position else constants.ZERO
+        ), True
+    return max_reducing_position_order_size, False
 
 
 def get_max_order_quantity_for_price(position, available_quantity, price, side, symbol):

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/personal_data/portfolios/portfolio_util.py

@@ -517,9 +517,9 @@ def get_portfolio_filled_orders_deltas(
                     < abs(max_allowed_equivalent_total_holding)
                     for expected_fee in (
                         # try with smaller fees in case user is paying less fees (when having large volume)
-                        expected_fee_related_deltas[asset_name] / decimal.Decimal(4),
-                        expected_fee_related_deltas[asset_name] / decimal.Decimal(2),
-                        expected_fee_related_deltas[asset_name],
+                        # test from 10% up to 100% fees
+                        expected_fee_related_deltas[asset_name] * decimal.Decimal(multiplier / 10)
+                        for multiplier in range(1, 11)
                     )
                 )
             )

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/personal_data/portfolios/sub_portfolio_data.py

@@ -58,6 +58,12 @@ class SubPortfolioData:
                     commons_constants.PORTFOLIO_TOTAL: delta_values[commons_constants.PORTFOLIO_TOTAL],
                     commons_constants.PORTFOLIO_AVAILABLE: delta_values[commons_constants.PORTFOLIO_AVAILABLE],
                 }
+            for key in (commons_constants.PORTFOLIO_TOTAL, commons_constants.PORTFOLIO_AVAILABLE):
+                if updated_content[asset][key] < constants.ZERO:
+                    commons_logging.get_logger(__name__).warning(
+                        f"{asset} portfolio {key} value: {updated_content[asset][key]} is < 0. Replacing with zero."
+                    )
+                    updated_content[asset][key] = constants.ZERO
         return updated_content
 
     def get_content_from_total_deltas_and_locked_funds(self) -> dict[str, dict[str, decimal.Decimal]]:

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/octobot_trading/personal_data/positions/position.py

@@ -62,12 +62,12 @@ class Position(util.Initializable):
         self.fee_to_close = constants.ZERO
 
         # Size
-        self.quantity = constants.ZERO
-        self.size = constants.ZERO
+        self.quantity = constants.ZERO  # unleverage size
+        self.size = constants.ZERO  # size of the position (in asset)
         self.already_reduced_size = constants.ZERO
-        self.value = constants.ZERO
-        self.initial_margin = constants.ZERO
-        self.margin = constants.ZERO
+        self.value = constants.ZERO # value of the position
+        self.initial_margin = constants.ZERO    # locked funds from the wallet to maintain position
+        self.margin = constants.ZERO    # initial_margin + fee to close
         self.auto_deposit_margin = False
 
         # PNL
@@ -349,6 +349,9 @@ class Position(util.Initializable):
             if self.size == constants.ZERO:
                 self.creation_time = self.exchange_manager.exchange.get_exchange_current_time()
             self.update_average_entry_price(size_update, order.filled_price)
+        elif self._is_update_reversing_side(size_update):
+            # don't use size_update here as it is larger than size
+            self._update_exit_data(size_to_close, self.mark_price)
         elif self._is_update_decreasing_size(size_update):
             self._update_exit_data(size_update, self.mark_price)
 
@@ -413,6 +416,15 @@ class Position(util.Initializable):
             return size_update < constants.ZERO
         return size_update > constants.ZERO
 
+    def _is_update_reversing_side(self, size_update):
+        """
+        :param size_update: the size update
+        :return: True if this update will reverse position side
+        """
+        if self.is_long():
+            return self.size + size_update < constants.ZERO
+        return self.size + size_update > constants.ZERO
+
     def _is_update_closing(self, size_update):
         """
         :param size_update: the size update
@@ -440,10 +452,16 @@ class Position(util.Initializable):
         """
         margin_update = constants.ZERO
         is_update_increasing_position_size = self._is_update_increasing_size(size_update)
-        if self._is_update_decreasing_size(size_update):
+        if self._is_update_reversing_side(size_update):
+            realised_pnl_update += self._update_realized_pnl_from_size_update(
+                self.get_quantity_to_close(), is_closing=True,
+                update_price=self.mark_price, trigger_source=trigger_source
+            )
+        elif self._is_update_decreasing_size(size_update):
             realised_pnl_update += self._update_realized_pnl_from_size_update(
                 size_update, is_closing=self._is_update_closing(size_update),
-                update_price=self.mark_price, trigger_source=trigger_source)
+                update_price=self.mark_price, trigger_source=trigger_source
+            )
         self._check_and_update_size(size_update)
         self._update_quantity()
         self._update_side(True)
@@ -510,7 +528,7 @@ class Position(util.Initializable):
 
     def _update_quantity(self):
         """
-        Update position quantity from position quantity
+        Update position quantity from position size
         """
         self.quantity = self.size / self.symbol_contract.current_leverage
 
@@ -714,6 +732,7 @@ class Position(util.Initializable):
         if reset_entry_price:
             self._reset_entry_price()
         self.exit_price = constants.ZERO
+        self.already_reduced_size = constants.ZERO
         # use update_timestamp when available, use exchange time otherwise
         self.creation_time = creation_timestamp or self.exchange_manager.exchange.get_exchange_current_time()
         logging.get_logger(self.get_logger_name()).debug(f"Changed position side: now {self.side.name}")

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/tests/personal_data/orders/test_order_util.py

@@ -323,10 +323,12 @@ async def test_get_futures_max_order_size(future_trader_simulator_with_default_l
            (l1_current_symbol_holding * default_contract.current_leverage).quantize(compare_accuracy)
     assert l2_market_quantity.quantize(compare_accuracy) == \
            (l1_market_quantity * default_contract.current_leverage).quantize(compare_accuracy)
-    assert personal_data.get_futures_max_order_size(
+    full_buy_size, increasing = personal_data.get_futures_max_order_size(
         exchange_manager_inst, symbol, enums.TradeOrderSide.BUY,
         decimal.Decimal("37000"), False, l2_current_symbol_holding, l2_market_quantity
-    ) == (decimal.Decimal('0.1346503937177512307045985802'), True)
+    )
+    assert (full_buy_size, increasing) == (decimal.Decimal('0.1346503937177512307045985802'), True)
+
     # reduce only (position is empty)
     assert personal_data.get_futures_max_order_size(
         exchange_manager_inst, symbol, enums.TradeOrderSide.BUY,
@@ -334,19 +336,22 @@ async def test_get_futures_max_order_size(future_trader_simulator_with_default_l
     ) == (constants.ZERO, False)
 
     # with short position
-    assert personal_data.get_futures_max_order_size(
+    full_sell_size, increasing = personal_data.get_futures_max_order_size(
         exchange_manager_inst, symbol, enums.TradeOrderSide.SELL,
         decimal.Decimal("37000"), False, l2_current_symbol_holding, l2_market_quantity
-    ) == (decimal.Decimal('0.1345431452958334678764786291'), True)
+    )
+    assert (full_sell_size, increasing) == (decimal.Decimal('0.1345431452958334678764786291'), True)
     # reduce only (position is empty)
     assert personal_data.get_futures_max_order_size(
         exchange_manager_inst, symbol, enums.TradeOrderSide.SELL,
         decimal.Decimal("37000"), True, l2_current_symbol_holding, l2_market_quantity
     ) == (constants.ZERO, False)
 
+    # LONG POSITION
     # reduce only (position is NOT empty)
     position = exchange_manager_inst.exchange_personal_data.positions_manager.get_symbol_positions(symbol)[0]
     await position.update(mark_price=decimal.Decimal(37000), update_margin=decimal.Decimal(4))
+    # position is now long
     position_size = position.size
     assert position_size == decimal.Decimal("0.0005405405405405405405405405405")
     assert personal_data.get_futures_max_order_size(
@@ -354,6 +359,43 @@ async def test_get_futures_max_order_size(future_trader_simulator_with_default_l
         decimal.Decimal("37000"), True, l2_current_symbol_holding, l2_market_quantity
     ) == (position_size, False)
 
+    # not reduce only and long position: can reverse position
+    position_size = position.size
+    assert position_size == decimal.Decimal("0.0005405405405405405405405405405")    # still the same size
+    max_size, increasing = personal_data.get_futures_max_order_size(
+        exchange_manager_inst, symbol, enums.TradeOrderSide.SELL,
+        decimal.Decimal("37000"), False, l2_current_symbol_holding, l2_market_quantity
+    )
+    assert increasing is True
+    assert max_size > position_size
+    # higher than when just opening a position with full free funds
+    assert max_size > full_sell_size
+    assert max_size == decimal.Decimal("0.1352986545732659722297027996")
+
+    # SHORT POSITION
+    # reduce only (position is NOT empty)
+    await position.update(mark_price=decimal.Decimal(37000), update_margin=decimal.Decimal(-500))
+    # position is now short
+    position_size = position.size
+    assert position_size == decimal.Decimal("-0.06702702702702702702702702703")
+    assert personal_data.get_futures_max_order_size(
+        exchange_manager_inst, symbol, enums.TradeOrderSide.BUY,
+        decimal.Decimal("37000"), True, l2_current_symbol_holding, l2_market_quantity
+    ) == (-position_size, False)
+
+    # not reduce only and short position: can reverse position
+    position_size = position.size
+    assert position_size == decimal.Decimal("-0.06702702702702702702702702703")    # still the same size
+    max_size, increasing = personal_data.get_futures_max_order_size(
+        exchange_manager_inst, symbol, enums.TradeOrderSide.BUY,
+        decimal.Decimal("37000"), False, l2_current_symbol_holding, l2_market_quantity
+    )
+    assert increasing is True
+    assert max_size > abs(position_size)
+    # higher than when just opening a position with full free funds
+    assert max_size > full_sell_size
+    assert max_size == decimal.Decimal("0.2149168523362071749168523362")
+
 
 @pytest.mark.asyncio
 async def test_create_as_chained_order_regular_order(trader_simulator):
@@ -622,6 +664,119 @@ def test_get_valid_split_orders():
     ) == ([decimal.Decimal('0.14985')], [decimal.Decimal('0.0006963')])
 
 
+def test_get_valid_split_orders_with_amount_ratio_per_order():
+    # example SOL/BTC values from 12/09/2023
+    symbol_market = {
+        enums.ExchangeConstantsMarketStatusColumns.LIMITS.value: {
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT_MIN.value: 0.01,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_AMOUNT_MAX.value: 90000000.0,
+            },
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST_MIN.value: 0.0001,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_COST_MAX.value: 9000000.0
+            },
+            enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE.value: {
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE_MIN.value: 1e-07,
+                enums.ExchangeConstantsMarketStatusColumns.LIMITS_PRICE_MAX.value: 1000.0
+            },
+        },
+        enums.ExchangeConstantsMarketStatusColumns.PRECISION.value: {
+            enums.ExchangeConstantsMarketStatusColumns.PRECISION_PRICE.value: 7,
+            enums.ExchangeConstantsMarketStatusColumns.PRECISION_AMOUNT.value: 2
+        }
+    }
+
+    # all valid values
+    input_prices = [
+        decimal.Decimal("0.0006858"),
+        decimal.Decimal("0.0006908"),
+        decimal.Decimal("0.0006938"),
+        decimal.Decimal("0.0006958"),
+    ]
+    amount_ratio_per_order = [
+        decimal.Decimal("0.12"),
+        decimal.Decimal("0.24"),
+        decimal.Decimal("0.36"),
+        decimal.Decimal("0.28"),
+    ]
+    # invalid inputs
+    with pytest.raises(ValueError):
+        personal_data.get_valid_split_orders(
+            decimal.Decimal("2"),
+            input_prices,
+            symbol_market,
+            amount_ratio_per_order=[1, 2, 3]    # not enough values
+        )
+    with pytest.raises(ValueError):
+        personal_data.get_valid_split_orders(
+            decimal.Decimal("2"),
+            [decimal.Decimal("0.5")],
+            symbol_market,
+            amount_ratio_per_order=[decimal.Decimal(0)]    # 0 values
+        )
+    with pytest.raises(ValueError):
+        personal_data.get_valid_split_orders(
+            decimal.Decimal("2"),
+            [decimal.Decimal("0.5")],
+            symbol_market,
+            amount_ratio_per_order=[decimal.Decimal(-1.2)]    # negative values
+        )
+
+    # valid inputs
+    volumes, prices = personal_data.get_valid_split_orders(
+        decimal.Decimal("2"),
+        input_prices,
+        symbol_market,
+        amount_ratio_per_order=amount_ratio_per_order
+    )
+    assert (volumes, prices) == (
+        [decimal.Decimal("2") * amount_ratio for amount_ratio in amount_ratio_per_order],
+        prices
+    )
+    assert sum(volumes) == decimal.Decimal("2")
+
+    # too small amount for cost: adapt to 2 orders
+    amount_ratio_per_order = [decimal.Decimal(33), decimal.Decimal(44), decimal.Decimal(55), decimal.Decimal(66)]
+    total_ratio = sum(amount_ratio_per_order[:2])
+    volumes, prices = personal_data.get_valid_split_orders(
+        decimal.Decimal("0.5"),
+        input_prices,
+        symbol_market,
+        amount_ratio_per_order=amount_ratio_per_order
+    )
+    assert (volumes, prices) == (
+        [decimal.Decimal("0.5") * amount_ratio/total_ratio for amount_ratio in amount_ratio_per_order[:2]],
+        prices
+    )
+    assert sum(volumes) == decimal.Decimal("0.5")
+
+    # too small amount for cost: adapt to 1 order
+    volumes, prices = personal_data.get_valid_split_orders(
+        decimal.Decimal("0.1"),
+        input_prices,
+        symbol_market,
+        amount_ratio_per_order=amount_ratio_per_order
+    )
+    assert (volumes, prices) == ([decimal.Decimal('0.1')], [decimal.Decimal('0.0006858')])
+
+    # too small amount for cost (because of the lowest price order amount that gets truncated because of
+    # exchange precision rules): adapt to 0 orders
+
+    input_prices = [
+        decimal.Decimal("0.0006963"),
+        decimal.Decimal("0.0006908"),
+        decimal.Decimal("0.0006938"),
+        decimal.Decimal("0.0006958"),
+    ]
+    assert personal_data.get_valid_split_orders(
+        decimal.Decimal("0.14985"),
+        input_prices,
+        symbol_market,
+        amount_ratio_per_order=amount_ratio_per_order
+    ) == ([decimal.Decimal('0.14985')], [decimal.Decimal('0.0006963')])
+
+
 def test_get_split_orders_count_and_increment():
     # example SOL/BTC values from 12/09/2023
     symbol_market = {

{OctoBot-Trading-2.4.174 → OctoBot-Trading-2.4.176}/tests/personal_data/portfolios/test_portfolio_util.py

@@ -258,6 +258,21 @@ def test_resolve_sub_portfolios_with_filling_assets():
     )
 
 
+def test_resolve_sub_portfolios_with_unexpected_deltas():
+    # more delta in post trade portfolio than actual orders => do not result in negative subportfolio
+    master_pf = _sub_pf(0, _content({"BTC": 0.05, "TRX": 0, "USDT": 200}))
+    sub_pft = _sub_pf(
+        0,
+        _content({"BTC": 0.05, "TRX": 13.1, "USDT": 100}),
+        funds_deltas=_content({"BTC": -0.05, "TRX": -13.2, "USDT": 100}),
+    )
+
+    assert personal_data.resolve_sub_portfolios(master_pf, [sub_pft], [], [], {}) == (
+        _sub_pf(0,  _content({"BTC": 0.05, "TRX": 0, "USDT": 0})),
+        [_sub_pf(0, _content({"BTC": 0, "TRX": 0, "USDT": 200}))]
+    )
+
+
 def test_get_portfolio_filled_orders_deltas():
     pre_trade_content = _content({"BTC": 0.1, "USDT": 1000})
     post_trade_content = _content({"BTC": 0.2, "USDT": 500})