feat(config): replace max_to_lend with max_offer_size for smoothed lending

Remove redundant \max_to_lend\, \max_percent_to_lend\, and \max_to_lend_rate\ configurations that conflicted with the FRR strategy.

Introduce \max_offer_size\ to cap the maximum amount of a single loan offer, allowing unused balances to carry over for smoothed lending rates over time.

Simplify \MaxToLend.py\ to exclusively handle \max_active_amount\ global caps.

Update documentation and configuration templates to reflect these changes.

Add comprehensive test coverage for \max_offer_size\ order sizing and remainder precision logic.

Author: Carton

.gitignore

@@ -117,4 +117,5 @@ desktop.ini
 *.pem
 secrets/
 credentials.json
-.secrets/
+.secrets/
+BITFINEX

TODO.md

@@ -16,5 +16,5 @@
 - [x] Clean unused options in config
 - [x] Make rate:dur mapping configurable in Settings
 - [x] Make my added features configurable in web settings (like frrdelta) and add proper docs for them
-- [ ] max_to_lend/max_percent_to_lend/max_to_lend_rate: These 3 config options are not useful and may conflict with FFR strategy? Consider removing them
+- [x] max_to_lend/max_percent_to_lend/max_to_lend_rate: These 3 config options are not useful and may conflict with FFR strategy? Consider removing them
 

config_sample.toml

@@ -92,13 +92,11 @@ min_loan_size = 0.01
 # >0 = limit (cap total lending to this amount, e.g., 1000 for USD means max 1000 USD total lent)
 max_active_amount = -1
 
-# How much to lend out
-# Raw maximum amount to lend if under max_to_lend_rate. 0 or commented = check max_percent_to_lend
-max_to_lend = 0
-# Maximum percent to lend if under max_to_lend_rate. 0 or commented = 100%
-max_percent_to_lend = 0
-# Max to lend conditional rate. If > 0, the limits above apply when rate <= max_to_lend_rate.
-max_to_lend_rate = 0
+# Limits the maximum amount of a single loan offer to smooth out lending rates over time.
+# Unused balance remains in the account and will be offered in the next bot cycle.
+# -1 = unlimited (no limit on single offer size, standard spreading applies)
+# >0 = limit (cap single offer to this amount, e.g., 100 for USD means each offer is max 100 USD)
+max_offer_size = -1
 
 # Lending Strategy Selection. "Spread" or "FRR" (Bitfinex only).
 # Spread: Standard gap/spread based lending.

docs/configuration.rst

@@ -271,48 +271,6 @@ Very few situations require you to change these settings.
     - Uncomment to enable.
     - Format: ``YEAR-MONTH-DAY``
 
-Max to be lent
---------------
-
-This feature group allows you to only lend a certain percentage of your total holding in a coin, until the lending rate surpasses a certain threshold. Then it will lend at max capacity. These settings are found in the ``[coin.default]`` section or specific ``[coin.SYMBOL]`` sections.
-
-- ``max_to_lend`` is a raw number of how much you will lend of each coin whose lending rate is below ``max_to_lend_rate``.
-
-    - Default value: 0 (disabled)
-    - Allowed range: 0 (disabled) or ``min_loan_size`` and up
-    - If set to 0, it is disabled.
-    - If disabled, the bot will check if ``max_percent_to_lend`` is enabled and use that instead.
-    - Setting this overrides ``max_percent_to_lend``.
-    - This is a setting for the raw value of coin that will be lent if the coin's lending rate is under ``max_to_lend_rate``.
-    - Has no effect if current rate is higher than ``max_to_lend_rate``.
-    - If the remainder (after subtracting ``max_to_lend``) in a coin's balance is less than ``min_loan_size``, then the remainder will be lent anyway. Otherwise, the coins would go to waste since you can't lend under ``min_loan_size``.
-
-- ``max_percent_to_lend`` is a percentage of how much you will lend of each coin whose lending rate is below ``max_to_lend_rate``.
-
-    - Default value: 0 (disabled)
-    - Allowed range: 0 (disabled) to 100 percent
-    - If set to 0, it is disabled.
-    - If disabled in addition to ``max_to_lend``, the entire feature will be disabled (100% of balance will be lent).
-    - This percentage is calculated per-coin, and is the percentage of the balance that will be lent if the coin's current rate is less than ``max_to_lend_rate``.
-    - Has no effect if current rate is higher than ``max_to_lend_rate``.
-    - If the remainder in a coin's balance is less than ``min_loan_size``, then the remainder will be lent anyway.
-
-
-- ``max_to_lend_rate`` is the rate threshold (in percent) when all coins are lent.
-
-    - Default value: 0 (disabled)
-    - Allowed range: 0 (disabled) or ``min_daily_rate`` to 5 percent
-    - Setting this to 0 with a limit in place causes the limit to always be active.
-    - When an individual coin's lending rate passes this threshold, all of the coin will be lent instead of applying the limits from ``max_to_lend`` or ``max_percent_to_lend``.
-
-.. code-block:: toml
-
-    [coin.default]
-    max_to_lend = 0
-    max_percent_to_lend = 0
-    max_to_lend_rate = 0
-
-
 Config per Coin
 ---------------
 
@@ -357,6 +315,24 @@ Max Active Amount (Limit Total Lending)
         min_loan_size = 150
         max_active_amount = 5000.0  # Only lend up to 5000 USD total
 
+Max Offer Size (Smooth Lending Over Time)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- ``max_offer_size`` limits the maximum amount of coin placed in a single loan offer. Found in the ``[coin.default]`` or specific ``[coin.SYMBOL]`` section.
+
+    - Default value: -1 (unlimited)
+    - Allowed values:
+        - ``-1`` = Unlimited (standard spreading applies)
+        - ``> 0`` = Limit (cap each individual offer to this amount)
+    - If set to >0, no individual loan offer will exceed this amount. Unused balance remains in your wallet and will be offered in the next bot cycle (e.g. 60 seconds later). This effectively creates a Dollar Cost Averaging (DCA) effect, smoothing out your lending rates over time.
+
+    Example configuration:
+
+    .. code-block:: toml
+
+        [coin.USD]
+        max_offer_size = 1000.0  # Never place an offer larger than 1000 USD
+
 
 Advanced logging and Web Display
 --------------------------------

docs/dev/config_rearch/config_implementation_plan.md

@@ -80,9 +80,6 @@ min_loan_size = 0.01
 min_daily_rate = 0.005
 max_daily_rate = 5.0
 max_active_amount = -1    # -1 = unlimited
-max_to_lend = 0           # 0 = unlimited
-max_percent_to_lend = 0   # 0 = 100%
-max_to_lend_rate = 0      # 0 = disabled
 strategy = "Spread"       # or "FRR"
 
 # Spread Strategy Params

docs/dev/config_rearch/config_validation_rules.md

@@ -45,9 +45,7 @@
 | `max_daily_rate` (old: `maxdailyrate`) | `Decimal` | `5.0` | `0.003 <= x <= 5.0` (in percent) | `Configuration.py:195` |
 | `min_loan_size` (old: `minloansize`) | `Decimal` | `0.01` | `>= 0.005` | `Configuration.py:244` |
 | `max_active_amount` (old: `maxactiveamount`) | `Decimal` | `-1` | `-1` = unlimited, `0` = disabled, `> 0` = limit (caps total lending) | `Configuration.py:85` |
-| `max_to_lend` (old: `maxtolend`) | `Decimal` | `0` | `>= 0`. `0` means unlimited/check percent. | `Configuration.py:179` |
-| `max_percent_to_lend` (old: `maxpercenttolend`) | `Decimal` | `0` | `0 <= x <= 100` | `Configuration.py:180` |
-| `max_to_lend_rate` (old: `maxtolendrate`) | `Decimal` | `0` | `>= 0` (in percent) | `Configuration.py:181` |
+| `max_offer_size` | `Decimal` | `-1` | `-1` = unlimited, `> 0` = cap on single offer size | `Configuration.py:90` |
 | `strategy` (old: `lending_strategy`) | `str` | `"Spread"` | Enum: `"Spread"`, `"FRR"` | `Configuration.py:190` |
 
 ### Spread Strategy

src/lendingbot/modules/Configuration.py

@@ -90,7 +90,7 @@ class CoinConfig(BaseModel):
     min_daily_rate: Decimal = Field(Decimal("0.005"), ge=0, le=5)
     max_daily_rate: Decimal = Field(Decimal("5.0"), ge=0, le=5)
 
-    @field_validator("min_daily_rate", "max_daily_rate", "max_to_lend_rate", mode="after")
+    @field_validator("min_daily_rate", "max_daily_rate", mode="after")
     @classmethod
     def convert_percent_to_decimal(cls, v: Decimal) -> Decimal:
         return v / 100
@@ -101,9 +101,10 @@ def convert_percent_to_decimal(cls, v: Decimal) -> Decimal:
     #    0 = disabled (skip this coin entirely, equivalent to not including in all_currencies)
     #   >0 = limit (cap total lending to this amount in coin units, e.g., 1000 USD)
     max_active_amount: Decimal = Decimal("-1")
-    max_to_lend: Decimal = Decimal("0")
-    max_percent_to_lend: Decimal = Field(Decimal("0"), ge=0, le=100)
-    max_to_lend_rate: Decimal = Decimal("0")
+    # max_offer_size: Limits the maximum amount of a *single* loan offer.
+    #   -1 = unlimited (no limit on single offer size)
+    #   >0 = limit (cap single offer to this amount in coin units, e.g., 1000 USD)
+    max_offer_size: Decimal = Decimal("-1")
 
     # Strategy
     strategy: LendingStrategy = LendingStrategy.SPREAD

src/lendingbot/modules/Lending.py

@@ -576,13 +576,24 @@ def construct_orders(
 
         new_order_rates = sorted(set(order_rates))
         new_order_amounts = []
+
+        cur_max_offer_size = Decimal("-1")
+        if cfg := self.coin_cfg.get(cur):
+            cur_max_offer_size = cfg.max_offer_size
+
         for _ in range(len(new_order_rates)):
-            new_amount = self.data.truncate(cur_active_bal / len(new_order_rates), 8)
-            new_order_amounts.append(Decimal(str(new_amount)))
+            new_amount = Decimal(str(self.data.truncate(cur_active_bal / len(new_order_rates), 8)))
+            if cur_max_offer_size > 0 and new_amount > cur_max_offer_size:
+                new_amount = cur_max_offer_size
+            new_order_amounts.append(new_amount)
 
         remainder = cur_active_bal - sum(new_order_amounts)
         if remainder > 0:  # If truncating causes remainder, add that to first order.
-            new_order_amounts[0] += remainder
+            if cur_max_offer_size <= 0:
+                new_order_amounts[0] += remainder
+            elif new_order_amounts[0] < cur_max_offer_size:
+                allowance = cur_max_offer_size - new_order_amounts[0]
+                new_order_amounts[0] += min(remainder, allowance)
 
         resp = {"amounts": new_order_amounts, "rates": new_order_rates}
         return resp
@@ -677,10 +688,8 @@ def lend_cur(
         # Pass the total_lent for this currency to enable max_active_amount limit
         cur_total_lent = total_lent.get(active_cur, Decimal(0))
         active_bal = MaxToLend.amount_to_lend(
-            active_cur_total_balance,
             active_cur,
             Decimal(str(lending_balances[active_cur])),
-            Decimal(str(order_book["rates"][0])),
             total_lent=cur_total_lent,
         )
 
@@ -749,9 +758,7 @@ def lend_all(self) -> None:
 
         for cur in sorted(total_lent):
             if not lending_balances or cur not in lending_balances:
-                MaxToLend.amount_to_lend(
-                    total_lent[cur], cur, Decimal(0), Decimal(0), total_lent=total_lent[cur]
-                )
+                MaxToLend.amount_to_lend(cur, Decimal(0), total_lent=total_lent[cur])
 
         usable_currencies = 0
         ticker: dict[str, dict[str, str]] | None = None

src/lendingbot/modules/MaxToLend.py

@@ -2,13 +2,10 @@
 
 from . import Configuration
 from .Logger import Logger
-from .Utils import format_amount_currency, format_rate_pct
+from .Utils import format_amount_currency
 
 
 coin_cfg: dict[str, Configuration.CoinConfig] = {}
-max_to_lend_rate: Decimal = Decimal(0)
-max_to_lend: Decimal = Decimal(0)
-max_percent_to_lend: Decimal = Decimal(0)
 min_loan_size: Decimal = Decimal("0.001")
 log: Logger | None = None
 
@@ -21,36 +18,29 @@ def init(config: Configuration.RootConfig, log1: Logger) -> None:
         config: The configuration object.
         log1: The logger instance.
     """
-    global coin_cfg, max_to_lend_rate, max_to_lend, max_percent_to_lend, min_loan_size, log
+    global coin_cfg, min_loan_size, log
 
     # Populate coin_cfg with configured coins (merged with defaults by get_coin_config)
     coin_cfg = {}
     for symbol in config.coin:
         coin_cfg[symbol] = config.get_coin_config(symbol)
 
     default_coin = config.get_coin_config("default")
-    max_to_lend = default_coin.max_to_lend
-    max_percent_to_lend = default_coin.max_percent_to_lend
-    max_to_lend_rate = default_coin.max_to_lend_rate
     min_loan_size = default_coin.min_loan_size
     log = log1
 
 
 def amount_to_lend(
-    active_cur_test_balance: Decimal,
     active_cur: str,
     lending_balance: Decimal,
-    low_rate: Decimal,
     total_lent: Decimal = Decimal(0),
 ) -> Decimal:
     """
-    Calculates the actual amount to lend based on limits and market rates.
+    Calculates the actual amount to lend based on absolute limits.
 
     Args:
-        active_cur_test_balance: The total balance of the currency (lending + on-order).
         active_cur: The currency symbol.
         lending_balance: The available balance in the lending account.
-        low_rate: The lowest rate currently in the order book.
         total_lent: The amount currently lent out (active loans).
 
     Returns:
@@ -59,18 +49,9 @@ def amount_to_lend(
     if log is None:
         return lending_balance
 
-    restrict_lend = False
-    active_bal = Decimal(0)
-    log_data = ""
-    cur_max_to_lend_rate = max_to_lend_rate
-    cur_max_to_lend = max_to_lend
-    cur_max_percent_to_lend = max_percent_to_lend
-    cur_max_active_amount = Decimal(-1)
+    cur_max_active_amount = Decimal("-1")
 
     if cfg := coin_cfg.get(active_cur):
-        cur_max_to_lend_rate = cfg.max_to_lend_rate
-        cur_max_to_lend = cfg.max_to_lend
-        cur_max_percent_to_lend = cfg.max_percent_to_lend
         cur_max_active_amount = cfg.max_active_amount
 
     # Check max_active_amount limit first (absolute cap on total lending)
@@ -97,44 +78,4 @@ def amount_to_lend(
             )
             lending_balance = available_capacity
 
-    if (cur_max_to_lend_rate == 0 and low_rate > 0) or cur_max_to_lend_rate >= low_rate > 0:
-        log_data = (
-            f"The Lower Rate found on {active_cur} is {format_rate_pct(low_rate)} "
-            f"vs conditional rate {format_rate_pct(cur_max_to_lend_rate)}. "
-        )
-        restrict_lend = True
-
-    if cur_max_to_lend != 0 and restrict_lend:
-        log.updateStatusValue(active_cur, "maxToLend", cur_max_to_lend)
-        if lending_balance > (active_cur_test_balance - cur_max_to_lend):
-            active_bal = lending_balance - (active_cur_test_balance - cur_max_to_lend)
-
-    if cur_max_to_lend == 0 and cur_max_percent_to_lend != 0 and restrict_lend:
-        log.updateStatusValue(
-            active_cur, "maxToLend", (cur_max_percent_to_lend * active_cur_test_balance)
-        )
-        if lending_balance > (
-            active_cur_test_balance - (cur_max_percent_to_lend * active_cur_test_balance)
-        ):
-            active_bal = lending_balance - (
-                active_cur_test_balance - (cur_max_percent_to_lend * active_cur_test_balance)
-            )
-
-    if cur_max_to_lend == 0 and cur_max_percent_to_lend == 0:
-        log.updateStatusValue(active_cur, "maxToLend", active_cur_test_balance)
-        active_bal = lending_balance
-
-    if not restrict_lend:
-        log.updateStatusValue(active_cur, "maxToLend", active_cur_test_balance)
-        active_bal = lending_balance
-
-    if (lending_balance - active_bal) < min_loan_size:
-        active_bal = lending_balance
-
-    if active_bal < lending_balance:
-        log.log(
-            f"{log_data} Lending {format_amount_currency(active_bal, active_cur)} "
-            f"of {format_amount_currency(lending_balance, active_cur)} Available"
-        )
-
-    return active_bal
+    return lending_balance