OctoBot-Trading 2.4.78__tar.gz → 2.4.80__tar.gz

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/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.80] - 2024-05-10
+### Fixed
+- [Orders] missing trading permission error
+
+## [2.4.79] - 2024-04-24
+### Updated
+- [Keywords] add ignored orders to amount keyword
+
 ## [2.4.78] - 2024-04-15
 ### Added
 - [Exchanges] key adapter

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/constants.py

@@ -131,9 +131,13 @@ EXCHANGE_PERMISSION_ERRORS: typing.List[typing.Iterable[str]] = [
     # OKX ex: okx {"msg":"API key doesn't exist","code":"50119"}
     ("api", "key"),
 
+    # Binance ex: DDoSProtection('binance {"code":-2015,"msg":"Invalid API-key, IP, or permissions for action."}')
+    ("key", "permissions for action"),
+
     # coinbase ex: coinbase {"error":"PERMISSION_DENIED",
     # "error_details":"Missing required scopes","message":"Missing required scopes"}
     ("permission_denied", "required scopes"),
+    ("missing required scopes"),
 ]
 
 # text content of errors due to exchange compliancy rules

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/exchanges/types/rest_exchange.py

@@ -206,6 +206,12 @@ class RestExchange(abstract_exchange.AbstractExchange):
             ) from err
         except ccxt.DDoSProtection as e:
             # raised upon rate limit issues, last response data might have details on what is happening
+            # ensure this is not a permission error (can happen on binance)
+            if exchanges_util.is_api_permission_error(e):
+                # invalid api key or missing trading rights
+                raise errors.AuthenticationError(
+                    f"Error when handling order {e}. Please make sure that trading permissions are on for this API key."
+                ) from e
             if self.should_log_on_ddos_exception(e):
                 self.connector.log_ddos_error(e)
             raise errors.FailedRequest(f"Failed to order operation: {e.__class__.__name__} {e}") from e

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/modes/script_keywords/basic_keywords/account_balance.py

@@ -49,8 +49,10 @@ async def total_account_balance(context, side=trading_enums.PositionSide.BOTH.va
                               f"the reference market. reference market: {reference_market}, symbol: {context.symbol}")
 
 
-async def available_account_balance(context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False,
-                                    is_stop_order=False, reduce_only=True, target_price=None):
+async def available_account_balance(
+    context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False,
+    is_stop_order=False, reduce_only=True, target_price=None, orders_to_be_ignored=None
+):
     portfolio_type = commons_constants.PORTFOLIO_TOTAL if use_total_holding else commons_constants.PORTFOLIO_AVAILABLE
     current_symbol_holding, _, market_quantity, price, _ = \
         await trading_personal_data.get_pre_order_data(context.exchange_manager,
@@ -67,6 +69,21 @@ async def available_account_balance(context, side=trading_enums.TradeOrderSide.B
     already_locked_amount = trading_constants.ZERO
     if use_total_holding and is_stop_order:
         already_locked_amount = _get_locked_amount_in_stop_orders(context, side)
+    if orders_to_be_ignored:
+        for order_to_be_ignored in orders_to_be_ignored:
+            if order_to_be_ignored.side == trading_enums.TradeOrderSide.BUY:
+                market_quantity += order_to_be_ignored.origin_quantity
+            else:
+                current_symbol_holding += order_to_be_ignored.origin_quantity
+        total_symbol_holding, _, total_market_quantity, _, _ = \
+            await trading_personal_data.get_pre_order_data(context.exchange_manager,
+                                                           symbol=context.symbol,
+                                                           timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
+                                                           portfolio_type=commons_constants.PORTFOLIO_TOTAL,
+                                                           target_price=target_price)
+        # ensure not using more than total amounts
+        current_symbol_holding = min(current_symbol_holding, total_symbol_holding)
+        market_quantity = min(market_quantity, total_market_quantity)
     return (market_quantity if side == trading_enums.TradeOrderSide.BUY.value else current_symbol_holding) \
         - already_locked_amount
 
@@ -80,11 +97,14 @@ def _get_locked_amount_in_stop_orders(context, side):
     return locked_amount
 
 
-async def adapt_amount_to_holdings(context, amount, side, use_total_holding, reduce_only,
-                                   is_stop_order, target_price=None):
-    available_acc_bal = await available_account_balance(context, side, use_total_holding=use_total_holding,
-                                                        is_stop_order=is_stop_order, reduce_only=reduce_only,
-                                                        target_price=target_price)
+async def adapt_amount_to_holdings(
+    context, amount, side, use_total_holding, reduce_only,
+    is_stop_order, target_price=None, orders_to_be_ignored=None
+):
+    available_acc_bal = await available_account_balance(
+        context, side, use_total_holding=use_total_holding, is_stop_order=is_stop_order,
+        reduce_only=reduce_only, target_price=target_price, orders_to_be_ignored=orders_to_be_ignored
+    )
     if available_acc_bal > amount:
         return amount
     else:

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/modes/script_keywords/basic_keywords/amount.py

@@ -13,7 +13,6 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
-
 import octobot_commons.symbols as commons_symbols
 import octobot_trading.modes.script_keywords.dsl as dsl
 import octobot_trading.modes.script_keywords.basic_keywords.account_balance as account_balance
@@ -32,6 +31,7 @@ async def get_amount_from_input_amount(
     use_total_holding=False,
     target_price=None,
     allow_holdings_adaptation=True,
+    orders_to_be_ignored=None,
 ):
     amount_type, amount_value = dsl.parse_quantity(input_amount)
 
@@ -81,7 +81,8 @@ async def get_amount_from_input_amount(
     else:
         raise trading_errors.InvalidArgumentError(f"Unsupported input: {input_amount} make sure to use a supported syntax for amount")
     adapted_amount = await account_balance.adapt_amount_to_holdings(
-        context, amount_value, side, use_total_holding, reduce_only, is_stop_order, target_price=target_price
+        context, amount_value, side, use_total_holding, reduce_only, is_stop_order,
+        target_price=target_price, orders_to_be_ignored=orders_to_be_ignored
     )
     if adapted_amount < amount_value and not allow_holdings_adaptation:
         raise trading_errors.MissingFunds(

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/personal_data/orders/order.py

@@ -546,16 +546,19 @@ class Order(util.Initializable):
         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
+        # consider worse case taker fees when using use_origin_quantity_and_price as the order is not filled yet
+        taker_or_maker = enums.ExchangeConstantsOrderColumns.TAKER.value \
+            if use_origin_quantity_and_price else self.taker_or_maker
         if self.fees_currency_side is enums.FeesCurrencySide.UNDEFINED:
             computed_fee = self.exchange_manager.exchange.get_trade_fee(
-                self.symbol, self.order_type, quantity, price, self.taker_or_maker
+                self.symbol, self.order_type, quantity, price, 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]
         else:
             symbol_fees = self.exchange_manager.exchange.get_fees(self.symbol)
-            fees = decimal.Decimal(f"{symbol_fees[self.taker_or_maker]}")
+            fees = decimal.Decimal(f"{symbol_fees[taker_or_maker]}")
             if self.fees_currency_side is enums.FeesCurrencySide.CURRENCY:
                 value = quantity / price * fees
                 currency = self.currency

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/octobot_trading/personal_data/portfolios/types/spot_portfolio.py

@@ -31,6 +31,9 @@ class SpotPortfolio(portfolio_class.Portfolio):
         """
         base_fees = order.get_total_fees(order.currency)
         quote_fees = order.get_total_fees(order.market)
+        forecasted_fees = order.get_computed_fee(use_origin_quantity_and_price=True)
+        forecasted_base_fees = order_util.get_fees_for_currency(forecasted_fees, order.currency)
+        forecasted_quote_fees = order_util.get_fees_for_currency(forecasted_fees, order.market)
 
         # update base
         if order.side == enums.TradeOrderSide.BUY:
@@ -38,12 +41,16 @@ class SpotPortfolio(portfolio_class.Portfolio):
             self._update_portfolio_data(order.currency, total_value=new_quantity, available_value=new_quantity)
         else:
             new_quantity = -order.filled_quantity - base_fees
-            self._update_portfolio_data(order.currency, total_value=new_quantity)
+            # Align available amount using really paid fees. Does nothing if forecasted fees == real fees
+            available_update = forecasted_base_fees - base_fees
+            self._update_portfolio_data(order.currency, total_value=new_quantity, available_value=available_update)
 
         # update quote
         if order.side == enums.TradeOrderSide.BUY:
             new_quantity = -(order.filled_quantity * order.filled_price) - quote_fees
-            self._update_portfolio_data(order.market, total_value=new_quantity)
+            # Align available amount using really paid fees. Does nothing if forecasted fees == real fees
+            available_update = forecasted_quote_fees - quote_fees
+            self._update_portfolio_data(order.market, total_value=new_quantity, available_value=available_update)
         else:
             new_quantity = (order.filled_quantity * order.filled_price) - quote_fees
             self._update_portfolio_data(order.market, total_value=new_quantity, available_value=new_quantity)

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/tests/exchanges/traders/test_trader.py

@@ -567,8 +567,9 @@ class TestTrader:
         with patch.object(ccxt.async_support.binanceus, "calculate_fee",
                           Mock(return_value=get_fees_mock("SOL"))) as calculate_fee_mock:
             await limit_buy.on_fill(force_fill=True)
-            # ensure call ccxt calculate_fee for order fees
-            calculate_fee_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert calculate_fee_mock.call_count == 2
 
         # added filled orders as filled trades
         assert len(trades_manager.trades) == 1
@@ -611,7 +612,9 @@ class TestTrader:
         with patch.object(ccxt.async_support.binanceus, "calculate_fee", Mock(return_value=get_fees_mock("SOL"))) \
                 as calculate_fee_mock:
             await limit_buy.on_fill(force_fill=True)
-            calculate_fee_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert calculate_fee_mock.call_count == 2
 
         assert limit_buy not in orders_manager.get_open_orders()
 

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/tests/modes/script_keywords/basic_keywords/test_account_balance.py

@@ -47,8 +47,17 @@ async def test_total_account_balance(mock_context):
 async def test_available_account_balance(mock_context):
     current_symbol_holding = decimal.Decimal("100")
     market_quantity = decimal.Decimal("50")
-    ret_val = (current_symbol_holding, "current_market_holding", market_quantity, "current_price", "symbol_market")
-    with mock.patch.object(trading_personal_data, "get_pre_order_data", mock.AsyncMock(return_value=ret_val)) \
+
+    async def _get_pre_order_data(
+        exchange_manager, symbol: str, timeout: int = None,
+        portfolio_type=commons_constants.PORTFOLIO_AVAILABLE,
+        target_price=None
+    ):
+        if portfolio_type == commons_constants.PORTFOLIO_AVAILABLE:
+            return current_symbol_holding, "current_market_holding", market_quantity, "current_price", "symbol_market"
+        return current_symbol_holding*2, "current_market_holding", market_quantity*2, "current_price", "symbol_market"
+
+    with mock.patch.object(trading_personal_data, "get_pre_order_data", mock.AsyncMock(side_effect=_get_pre_order_data)) \
             as get_pre_order_data_mock, \
             mock.patch.object(account_balance, "_get_locked_amount_in_stop_orders",
                               mock.Mock(return_value=trading_constants.ONE)) as _get_locked_amount_in_stop_orders_mock:
@@ -62,7 +71,7 @@ async def test_available_account_balance(mock_context):
                                                         target_price=trading_constants.ZERO)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.assert_not_called()
-        assert current_symbol_holding == await script_keywords.available_account_balance(
+        assert current_symbol_holding * 2 == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.SELL.value, use_total_holding=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -70,7 +79,7 @@ async def test_available_account_balance(mock_context):
                                                         target_price=None)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.assert_not_called()
-        assert current_symbol_holding - trading_constants.ONE == await script_keywords.available_account_balance(
+        assert current_symbol_holding * 2 - trading_constants.ONE == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.SELL.value, use_total_holding=True, is_stop_order=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -80,7 +89,7 @@ async def test_available_account_balance(mock_context):
                                                                        trading_enums.TradeOrderSide.SELL.value)
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.reset_mock()
-        assert market_quantity - trading_constants.ONE == await script_keywords.available_account_balance(
+        assert market_quantity * 2 - trading_constants.ONE == await script_keywords.available_account_balance(
             mock_context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=True, is_stop_order=True)
         get_pre_order_data_mock.assert_called_once_with(mock_context.exchange_manager, symbol=mock_context.symbol,
                                                         timeout=trading_constants.ORDER_DATA_FETCHING_TIMEOUT,
@@ -91,6 +100,25 @@ async def test_available_account_balance(mock_context):
         get_pre_order_data_mock.reset_mock()
         _get_locked_amount_in_stop_orders_mock.reset_mock()
 
+        buy_1 = trading_personal_data.BuyLimitOrder(mock_context.trader)
+        buy_1.origin_quantity = decimal.Decimal("10")
+        buy_1.origin_price = decimal.Decimal("100")
+        buy_2 = trading_personal_data.BuyLimitOrder(mock_context.trader)
+        buy_2.origin_quantity = decimal.Decimal("3")
+        buy_2.origin_price = decimal.Decimal("40")
+        sell_1 = trading_personal_data.SellLimitOrder(mock_context.trader)
+        sell_1.origin_quantity = decimal.Decimal("2.21")
+        sell_1.origin_price = decimal.Decimal("200")
+        assert market_quantity + buy_1.origin_quantity + buy_2.origin_quantity == \
+           await script_keywords.available_account_balance(
+                mock_context, side=trading_enums.TradeOrderSide.BUY.value, use_total_holding=False, is_stop_order=False,
+                orders_to_be_ignored=[buy_1, buy_2, sell_1]
+            )
+        assert get_pre_order_data_mock.call_count == 2
+        _get_locked_amount_in_stop_orders_mock.assert_not_called()
+        get_pre_order_data_mock.reset_mock()
+        _get_locked_amount_in_stop_orders_mock.reset_mock()
+
 
 async def test_adapt_amount_to_holdings(null_context):
     with mock.patch.object(account_balance, "available_account_balance",
@@ -106,18 +134,21 @@ async def test_adapt_amount_to_holdings(null_context):
         available_account_balance_mock.assert_called_once_with(null_context, trading_enums.TradeOrderSide.SELL,
                                                                use_total_holding=False, is_stop_order="is_stop_order",
                                                                reduce_only="reduce_only",
-                                                               target_price=trading_constants.ONE_HUNDRED)
+                                                               target_price=trading_constants.ONE_HUNDRED,
+                                                               orders_to_be_ignored=None)
         available_account_balance_mock.reset_mock()
         assert await script_keywords.adapt_amount_to_holdings(null_context,
                                                               decimal.Decimal(1),
                                                               trading_enums.TradeOrderSide.SELL,
                                                               True,
                                                               "reduce_only",
-                                                              "is_stop_order") == decimal.Decimal(1)
+                                                              "is_stop_order",
+                                                              orders_to_be_ignored=["plop"]) == decimal.Decimal(1)
         available_account_balance_mock.assert_called_once_with(null_context, trading_enums.TradeOrderSide.SELL,
                                                                use_total_holding=True, is_stop_order="is_stop_order",
                                                                reduce_only="reduce_only",
-                                                               target_price=None)
+                                                               target_price=None,
+                                                               orders_to_be_ignored=["plop"])
         assert await script_keywords.adapt_amount_to_holdings(null_context,
                                                               decimal.Decimal(2),
                                                               trading_enums.TradeOrderSide.SELL,

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/tests/modes/script_keywords/basic_keywords/test_amount.py

@@ -59,7 +59,8 @@ async def test_get_amount_from_input_amount(null_context):
                 assert await script_keywords.get_amount_from_input_amount(null_context, "1", "buy") \
                        == decimal.Decimal(1)
                 adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(2), "buy",
-                                                                      False, True, False, target_price=None)
+                                                                      False, True, False, target_price=None,
+                                                                      orders_to_be_ignored=None)
                 parse_quantity_mock.assert_called_once_with("1")
                 parse_quantity_mock.reset_mock()
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -67,10 +68,11 @@ async def test_get_amount_from_input_amount(null_context):
                 with pytest.raises(errors.MissingFunds):
                     # raises as 1 != 2
                     await script_keywords.get_amount_from_input_amount(
-                        null_context, "1", "buy", allow_holdings_adaptation=False
+                        null_context, "1", "buy", allow_holdings_adaptation=False, orders_to_be_ignored=[]
                     )
                 adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(2), "buy",
-                                                                      False, True, False, target_price=None)
+                                                                      False, True, False, target_price=None,
+                                                                      orders_to_be_ignored=[])
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
 
@@ -80,10 +82,12 @@ async def test_get_amount_from_input_amount(null_context):
                 for allow_holdings_adaptation in (True, False):
                     # doesn't raise as 1 == 1
                     assert await script_keywords.get_amount_from_input_amount(
-                        null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation
+                        null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation,
+                        orders_to_be_ignored=["plip"]
                     ) == decimal.Decimal(1)
                     adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal(1), "buy",
-                                                                          False, True, False, target_price=None)
+                                                                          False, True, False, target_price=None,
+                                                                          orders_to_be_ignored=["plip"])
                     parse_quantity_mock.assert_called_once_with("1")
                     parse_quantity_mock.reset_mock()
                     adapt_amount_to_holdings_mock.reset_mock()
@@ -97,7 +101,8 @@ async def test_get_amount_from_input_amount(null_context):
                         null_context, "1", "buy", allow_holdings_adaptation=allow_holdings_adaptation
                     ) == decimal.Decimal(1)
                     adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("0.5"), "buy",
-                                                                          False, True, False, target_price=None)
+                                                                          False, True, False, target_price=None,
+                                                                          orders_to_be_ignored=None)
                     parse_quantity_mock.assert_called_once_with("1")
                     parse_quantity_mock.reset_mock()
                     adapt_amount_to_holdings_mock.reset_mock()
@@ -117,7 +122,7 @@ async def test_get_amount_from_input_amount(null_context):
                 # without target_price
                 adapt_amount_to_holdings_mock.assert_called_once_with(
                     null_context, decimal.Decimal(2) / decimal.Decimal(100), "buy",
-                    False, True, False, target_price=None
+                    False, True, False, target_price=None, orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -130,7 +135,7 @@ async def test_get_amount_from_input_amount(null_context):
                 get_up_to_date_price_mock.assert_not_called()
                 adapt_amount_to_holdings_mock.assert_called_once_with(
                     null_context, decimal.Decimal(2) / decimal.Decimal(23), "buy",
-                    False, True, False, target_price=decimal.Decimal(23)
+                    False, True, False, target_price=decimal.Decimal(23), orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -142,7 +147,8 @@ async def test_get_amount_from_input_amount(null_context):
                         null_context, "1", "buy",  target_price=decimal.Decimal("0.5"), allow_holdings_adaptation=False
                     )
                 adapt_amount_to_holdings_mock.assert_called_once_with(
-                    null_context, decimal.Decimal(4), "buy", False, True, False, target_price=decimal.Decimal("0.5")
+                    null_context, decimal.Decimal(4), "buy", False, True, False, target_price=decimal.Decimal("0.5"),
+                    orders_to_be_ignored=None
                 )
                 parse_quantity_mock.assert_called_once_with("1")
                 adapt_amount_to_holdings_mock.reset_mock()
@@ -158,7 +164,8 @@ async def test_get_amount_from_input_amount(null_context):
                                                                       is_stop_order=True,
                                                                       target_price=constants.ZERO) == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("1.5"), "buy",
-                                                                  True, False, True, target_price=constants.ZERO)
+                                                                  True, False, True, target_price=constants.ZERO,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             available_account_balance_mock.assert_called_once_with(null_context, "buy",
                                                                    use_total_holding=True, reduce_only=False)
@@ -173,7 +180,8 @@ async def test_get_amount_from_input_amount(null_context):
                 as available_account_balance_mock:
             assert await script_keywords.get_amount_from_input_amount(null_context, "50", "buy") == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("1.5"), "buy",
-                                                                  False, True, False, target_price=None)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             available_account_balance_mock.assert_called_once_with(null_context, "buy",
                                                                    use_total_holding=False, reduce_only=True)
@@ -196,7 +204,8 @@ async def test_get_amount_from_input_amount(null_context):
 
             assert await script_keywords.get_amount_from_input_amount(null_context, "50", "buy") == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("1.5"), "buy",
-                                                                  False, True, False, target_price=None)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             get_holdings_value_mock.assert_called_once_with(("BTC", "USDT"), "BTC")
             adapt_amount_to_holdings_mock.reset_mock()
@@ -229,7 +238,8 @@ async def test_get_amount_from_input_amount(null_context):
 
             assert await script_keywords.get_amount_from_input_amount(null_context, "50", "buy") == decimal.Decimal(1)
             adapt_amount_to_holdings_mock.assert_called_once_with(null_context, decimal.Decimal("7.5"), "buy",
-                                                                  False, True, False, target_price=None)
+                                                                  False, True, False, target_price=None,
+                                                                  orders_to_be_ignored=None)
             parse_quantity_mock.assert_called_once_with("50")
             get_holdings_value_mock.assert_called_once_with({'BTC', 'ETH', 'SOL', 'USDT'}, "BTC")
             adapt_amount_to_holdings_mock.reset_mock()

{OctoBot-Trading-2.4.78 → OctoBot-Trading-2.4.80}/tests/personal_data/portfolios/test_portfolio.py

@@ -259,40 +259,62 @@ async def test_update_portfolio_with_filled_orders(backtesting_trader):
                      current_price=decimal.Decimal(str(50)),
                      quantity=decimal.Decimal(str(2)),
                      price=decimal.Decimal(str(50)))
+    limit_buy_2 = BuyLimitOrder(trader)
+    limit_buy_2.update(order_type=TraderOrderType.BUY_LIMIT,
+                       symbol="BTC/USDT",
+                       current_price=decimal.Decimal(str(50)),
+                       quantity=decimal.Decimal(str(2)),
+                       price=decimal.Decimal(str(50)))
 
     # update portfolio with creations
     portfolio_manager.portfolio.update_portfolio_available(market_sell, True)
-    portfolio_manager.portfolio.update_portfolio_available(limit_sell, True)
     portfolio_manager.portfolio.update_portfolio_available(stop_loss, True)
-    portfolio_manager.portfolio.update_portfolio_available(limit_buy, True)
+    # simulate fees in USDT (ex: Kucoin, OKX)
+    with mock.patch.object(limit_buy.exchange_manager.exchange.connector, "_get_fees_currency", return_value="USDT") \
+         as _get_fees_currency_mock:
+        # taker fees are locked
+        portfolio_manager.portfolio.update_portfolio_available(limit_sell, True)
+        portfolio_manager.portfolio.update_portfolio_available(limit_buy, True)
+    portfolio_manager.portfolio.update_portfolio_available(limit_buy_2, True)
 
     assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('2.8')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('900')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('799.9')
 
     # when cancelling limit sell, market sell and stop orders
     portfolio_manager.portfolio.update_portfolio_available(stop_loss, False)
-    portfolio_manager.portfolio.update_portfolio_available(limit_sell, False)
+    # simulate fees in USDT (ex: Kucoin, OKX)
+    with mock.patch.object(limit_buy.exchange_manager.exchange.connector, "_get_fees_currency", return_value="USDT") \
+         as _get_fees_currency_mock:
+        portfolio_manager.portfolio.update_portfolio_available(limit_sell, False)
 
     assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('7')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('900')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('799.9')
 
     # when filling limit buy
-    await fill_limit_or_stop_order(limit_buy)
-    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('8.999')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('900')
-    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal('11.999')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal('900')
+    # simulate fees in USDT (ex: Kucoin, OKX)
+    with mock.patch.object(limit_buy.exchange_manager.exchange.connector, "_get_fees_currency", return_value="USDT") \
+         as _get_fees_currency_mock:
+        await fill_limit_or_stop_order(limit_buy)
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('9')
+    # USDT available is now 899.95 as maker fees are applied
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('799.95')
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal('12')
+    # USDT total is now 899.95 as maker fees are applied
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal('899.95')
 
     # when filling market sell
     await fill_market_order(market_sell)
-    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal(
-        '8.999')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal(
-        '1109.79')
-    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal(
-        '8.999')
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal(
-        '1109.79')
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('9')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('1009.74')
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal('9')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal('1109.74')
+
+    # when filling limit buy 2 (fees paid in BTC)
+    await fill_market_order(limit_buy_2)
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").available == decimal.Decimal('10.999')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('1009.74')
+    assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal('10.999')
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal('1009.74')
 
 
 async def test_update_portfolio_with_cancelled_orders(backtesting_trader):
@@ -349,15 +371,15 @@ async def test_update_portfolio_with_cancelled_orders(backtesting_trader):
         portfolio_manager.portfolio.update_portfolio_available(limit_buy, True)
     assert round(portfolio_manager.portfolio.get_currency_portfolio("BTC").available,
                  1) == decimal.Decimal('5.8')
-    # also locked 0.1 USDT for fees
-    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('799.9')
+    # also locked 0.2 USDT for fees (use taker fees to be sure to have enough funds if order is filled as taker)
+    assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal('799.8')
 
     portfolio_manager.portfolio.update_portfolio_available(market_sell, True)
 
     assert round(portfolio_manager.portfolio.get_currency_portfolio("BTC").available,
                  1) == decimal.Decimal('1.7')
     assert portfolio_manager.portfolio.get_currency_portfolio("USDT").available == decimal.Decimal(
-        '799.9')
+        '799.8')
     assert portfolio_manager.portfolio.get_currency_portfolio("BTC").total == decimal.Decimal(
         '10')
     assert portfolio_manager.portfolio.get_currency_portfolio("USDT").total == decimal.Decimal(
@@ -803,12 +825,16 @@ async def test_update_portfolio_with_multiple_filled_orders(backtesting_trader):
         with mock.patch.object(exchange_manager.exchange.connector, "_get_fees_currency", return_value="BTC") \
              as _get_fees_currency_mock:
             await fill_limit_or_stop_order(limit_sell)
-            _get_fees_currency_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert _get_fees_currency_mock.call_count == 2
         await fill_limit_or_stop_order(limit_sell_3)
         with mock.patch.object(exchange_manager.exchange.connector, "_get_fees_currency", return_value="USDT") \
              as _get_fees_currency_mock:
             await fill_limit_or_stop_order(limit_buy_2)
-            _get_fees_currency_mock.assert_called_once()
+            # called twice: once for filled order fee calculation, once for forecasted fees calculation used to restore
+            # available amounts if relevant
+            assert _get_fees_currency_mock.call_count == 2
         await fill_limit_or_stop_order(limit_sell_5)
         await fill_limit_or_stop_order(stop_loss_4)
         await fill_limit_or_stop_order(limit_buy_4)