fix: convertDynamicToFixed prioritizes interest then principal deduction

Amount now clears interest first, then principal. New fixed position
principal <= amount. Also fix constructor args after rebase and add
exact-full and excess-capped conversion tests.

Author: ricklista

script/broker/deploy_broker_20260408.s.sol

@@ -55,7 +55,7 @@ contract DeployXautBrokers is DeployBase {
 
   function _deployBroker(string memory label, address relayer, address oracle, address deployer) internal {
     // Deploy implementation
-    LendingBroker impl = new LendingBroker(MOOLAH, relayer, oracle, address(0));
+    LendingBroker impl = new LendingBroker(MOOLAH, address(0));
     console.log(string.concat("LendingBroker(", label, ") impl: "), address(impl));
 
     // Deploy proxy

src/broker/LendingBroker.sol

@@ -439,15 +439,16 @@ contract LendingBroker is
     address user = msg.sender;
     DynamicLoanPosition storage position = dynamicLoanPositions[user];
     if (fixedLoanPositions[user].length >= maxFixedLoanPositions) revert ExceedMaxFixedPositions();
-    // cap amount by principal
-    amount = UtilsLib.min(amount, position.principal);
     // accrue current rate so normalized debt reflects the latest interest
     uint256 rate = IRateCalculator(rateCalculator).accrueRate(address(this));
     uint256 actualDebt = BrokerMath.denormalizeBorrowAmount(position.normalizedDebt, rate);
     uint256 totalInterest = actualDebt.zeroFloorSub(position.principal);
 
-    // force user to repay interest portion when converting to fixed
-    uint256 interestToRepay = BrokerMath.mulDivCeiling(amount, totalInterest, position.principal);
+    // prioritize clearing interest first, then principal
+    uint256 interestToRepay = UtilsLib.min(amount, totalInterest);
+    uint256 principalToMove = UtilsLib.min(amount - interestToRepay, position.principal);
+    amount = interestToRepay + principalToMove;
+
     if (interestToRepay > 0) {
       // borrow from Moolah to increase user's actual debt at moolah
       _borrowFromMoolah(user, interestToRepay);
@@ -456,9 +457,9 @@ contract LendingBroker is
     }
 
     position.normalizedDebt = position.normalizedDebt.zeroFloorSub(
-      BrokerMath.normalizeBorrowAmount(amount + interestToRepay, rate, false)
+      BrokerMath.normalizeBorrowAmount(amount, rate, false)
     );
-    position.principal -= amount;
+    position.principal -= principalToMove;
 
     if (position.principal == 0) {
       delete dynamicLoanPositions[user];
@@ -473,7 +474,7 @@ contract LendingBroker is
     fixedLoanPositions[user].push(
       FixedLoanPosition({
         posId: fixedPosUuid,
-        principal: amount + interestToRepay,
+        principal: amount,
         apr: term.apr,
         start: start,
         end: end,

test/broker/LendingBroker.t.sol

@@ -181,10 +181,20 @@ contract LendingBrokerTest is Test {
     );
     broker = LendingBroker(payable(address(bProxy)));
 
-    LendingBroker bnbImpl = new LendingBroker(address(moolah), address(bnbRelayer), address(oracle), address(WBNB));
+    LendingBroker bnbImpl = new LendingBroker(address(moolah), address(WBNB));
     ERC1967Proxy bnbProxy = new ERC1967Proxy(
       address(bnbImpl),
-      abi.encodeWithSelector(LendingBroker.initialize.selector, ADMIN, MANAGER, BOT, PAUSER, address(rateCalc), 10)
+      abi.encodeWithSelector(
+        LendingBroker.initialize.selector,
+        ADMIN,
+        MANAGER,
+        BOT,
+        PAUSER,
+        address(rateCalc),
+        10,
+        address(bnbRelayer),
+        address(oracle)
+      )
     );
     bnbBroker = LendingBroker(payable(address(bnbProxy)));
 
@@ -605,15 +615,11 @@ contract LendingBrokerTest is Test {
     uint256 actualDebt = BrokerMath.denormalizeBorrowAmount(normalizedBefore, rate);
     uint256 outstandingInterest = actualDebt > principalBefore ? actualDebt - principalBefore : 0;
 
+    // amount > interest => interest fully cleared, remainder moves principal
     uint256 convertAmount = 400 ether;
-    uint256 expectedInterestShare = outstandingInterest == 0
-      ? 0
-      : BrokerMath.mulDivCeiling(outstandingInterest, convertAmount, principalBefore);
-    uint256 expectedNormalizedDelta = BrokerMath.normalizeBorrowAmount(
-      convertAmount + expectedInterestShare,
-      rate,
-      true
-    );
+    uint256 expectedInterest = outstandingInterest < convertAmount ? outstandingInterest : convertAmount;
+    uint256 expectedPrincipalMove = convertAmount - expectedInterest;
+    uint256 expectedNormalizedDelta = BrokerMath.normalizeBorrowAmount(convertAmount, rate, true);
     uint256 expectedNormalizedAfter = normalizedBefore > expectedNormalizedDelta
       ? normalizedBefore - expectedNormalizedDelta
       : 0;
@@ -622,12 +628,12 @@ contract LendingBrokerTest is Test {
     broker.convertDynamicToFixed(convertAmount, 51);
 
     (uint256 principalAfter, uint256 normalizedAfter) = broker.dynamicLoanPositions(borrower);
-    assertEq(principalAfter, principalBefore - convertAmount, "dynamic principal not reduced by amount");
+    assertEq(principalAfter, principalBefore - expectedPrincipalMove, "dynamic principal not reduced correctly");
     assertApproxEqAbs(normalizedAfter, expectedNormalizedAfter, 1, "normalized debt delta mismatch");
 
     FixedLoanPosition[] memory fixedPositions = broker.userFixedPositions(borrower);
     assertEq(fixedPositions.length, 1, "fixed position not created");
-    assertEq(fixedPositions[0].principal, convertAmount + expectedInterestShare, "converted fixed principal incorrect");
+    assertEq(fixedPositions[0].principal, convertAmount, "fixed principal should equal amount");
     assertEq(fixedPositions[0].interestRepaid, 0);
     assertEq(fixedPositions[0].principalRepaid, 0);
   }
@@ -651,26 +657,91 @@ contract LendingBrokerTest is Test {
     uint256 rate = rateCalc.accrueRate(address(broker));
     uint256 actualDebt = BrokerMath.denormalizeBorrowAmount(normalizedBefore, rate);
     uint256 outstandingInterest = actualDebt > principalBefore ? actualDebt - principalBefore : 0;
-    uint256 expectedNormalizedDelta = BrokerMath.normalizeBorrowAmount(actualDebt, rate, true);
 
+    // pass amount > actualDebt => capped to interest + principal
     vm.prank(borrower);
-    broker.convertDynamicToFixed(principalBefore, 52);
+    broker.convertDynamicToFixed(actualDebt + 100 ether, 52);
 
     (uint256 principalAfter, uint256 normalizedAfter) = broker.dynamicLoanPositions(borrower);
     assertApproxEqAbs(principalAfter, 0, 1, "dynamic principal should be cleared");
     assertApproxEqAbs(normalizedAfter, 0, 1, "dynamic normalized debt should be cleared");
 
     FixedLoanPosition[] memory fixedPositions = broker.userFixedPositions(borrower);
     assertEq(fixedPositions.length, 1);
-    assertApproxEqAbs(
-      fixedPositions[0].principal,
-      principalBefore + outstandingInterest,
-      1,
-      "fixed principal should equal full outstanding debt"
-    );
+    uint256 expectedFixed = outstandingInterest + principalBefore;
+    assertApproxEqAbs(fixedPositions[0].principal, expectedFixed, 1, "fixed principal should equal full debt");
+  }
+
+  function test_convertDynamicToFixed_exactFullAmount() public {
+    FixedTermAndRate memory term = FixedTermAndRate({ termId: 53, duration: 60 days, apr: 105 * 1e25 });
+    vm.prank(BOT);
+    broker.updateFixedTermAndRate(term, false);
+
+    uint256 borrowAmt = 500 ether;
+    vm.prank(borrower);
+    broker.borrow(borrowAmt);
+
+    vm.prank(MANAGER);
+    rateCalc.setMaxRatePerSecond(address(broker), RATE_SCALE + 5);
+    vm.prank(BOT);
+    rateCalc.setRatePerSecond(address(broker), RATE_SCALE + 3);
+    skip(4 days);
 
-    // sanity: normalized delta consumed the whole normalized debt (allowing rounding wiggle)
-    assertApproxEqAbs(expectedNormalizedDelta, normalizedBefore, 1, "normalized debt delta rounding");
+    (uint256 principalBefore, uint256 normalizedBefore) = broker.dynamicLoanPositions(borrower);
+    uint256 rate = rateCalc.accrueRate(address(broker));
+    uint256 actualDebt = BrokerMath.denormalizeBorrowAmount(normalizedBefore, rate);
+    uint256 outstandingInterest = actualDebt > principalBefore ? actualDebt - principalBefore : 0;
+
+    // amount == interest + principal exactly
+    uint256 convertAmount = outstandingInterest + principalBefore;
+
+    vm.prank(borrower);
+    broker.convertDynamicToFixed(convertAmount, 53);
+
+    (uint256 principalAfter, uint256 normalizedAfter) = broker.dynamicLoanPositions(borrower);
+    assertApproxEqAbs(principalAfter, 0, 1, "dynamic principal should be cleared");
+    assertApproxEqAbs(normalizedAfter, 0, 1, "dynamic normalized debt should be cleared");
+
+    FixedLoanPosition[] memory fixedPositions = broker.userFixedPositions(borrower);
+    assertEq(fixedPositions.length, 1);
+    assertEq(fixedPositions[0].principal, convertAmount, "fixed principal should equal amount");
+  }
+
+  function test_convertDynamicToFixed_excessAmountCapped() public {
+    FixedTermAndRate memory term = FixedTermAndRate({ termId: 54, duration: 30 days, apr: 105 * 1e25 });
+    vm.prank(BOT);
+    broker.updateFixedTermAndRate(term, false);
+
+    uint256 borrowAmt = 600 ether;
+    vm.prank(borrower);
+    broker.borrow(borrowAmt);
+
+    vm.prank(MANAGER);
+    rateCalc.setMaxRatePerSecond(address(broker), RATE_SCALE + 5);
+    vm.prank(BOT);
+    rateCalc.setRatePerSecond(address(broker), RATE_SCALE + 3);
+    skip(3 days);
+
+    (uint256 principalBefore, uint256 normalizedBefore) = broker.dynamicLoanPositions(borrower);
+    uint256 rate = rateCalc.accrueRate(address(broker));
+    uint256 actualDebt = BrokerMath.denormalizeBorrowAmount(normalizedBefore, rate);
+    uint256 outstandingInterest = actualDebt > principalBefore ? actualDebt - principalBefore : 0;
+
+    // amount much larger than actualDebt => should be capped
+    uint256 convertAmount = actualDebt + 999 ether;
+
+    vm.prank(borrower);
+    broker.convertDynamicToFixed(convertAmount, 54);
+
+    (uint256 principalAfter, uint256 normalizedAfter) = broker.dynamicLoanPositions(borrower);
+    assertApproxEqAbs(principalAfter, 0, 1, "dynamic principal should be cleared");
+    assertApproxEqAbs(normalizedAfter, 0, 1, "dynamic normalized debt should be cleared");
+
+    FixedLoanPosition[] memory fixedPositions = broker.userFixedPositions(borrower);
+    assertEq(fixedPositions.length, 1);
+    uint256 expectedFixed = outstandingInterest + principalBefore;
+    assertApproxEqAbs(fixedPositions[0].principal, expectedFixed, 1, "fixed principal capped to actual debt");
+    assertLe(fixedPositions[0].principal, convertAmount, "fixed principal must be <= amount");
   }
 
   // -----------------------------
@@ -1759,7 +1830,7 @@ contract LendingBrokerTest is Test {
 
   /// @dev Deploy a fresh broker proxy with RELAYER/ORACLE unset (simulating V1->V2 upgrade)
   function _deployBrokerWithEmptyRelayerOracle() internal returns (LendingBroker) {
-    LendingBroker bImpl = new LendingBroker(address(moolah));
+    LendingBroker bImpl = new LendingBroker(address(moolah), address(0));
     // Use 6-param initialize (no relayer/oracle) by encoding only the original params
     // and leaving RELAYER/ORACLE as address(0)
     ERC1967Proxy bProxy = new ERC1967Proxy(

test/utils/PositionManager.t.sol

@@ -230,10 +230,20 @@ contract PositionManagerTest is Test {
     rateCalc = RateCalculator(address(rcProxy));
 
     // ── Deploy inBroker (LendingBroker for the fixed-term market) ────────────
-    LendingBroker bImpl = new LendingBroker(address(moolah), address(relayer), address(oracle), address(wbnb));
+    LendingBroker bImpl = new LendingBroker(address(moolah), address(wbnb));
     ERC1967Proxy bProxy = new ERC1967Proxy(
       address(bImpl),
-      abi.encodeWithSelector(LendingBroker.initialize.selector, admin, manager, bot, pauser, address(rateCalc), 100)
+      abi.encodeWithSelector(
+        LendingBroker.initialize.selector,
+        admin,
+        manager,
+        bot,
+        pauser,
+        address(rateCalc),
+        100,
+        address(relayer),
+        address(oracle)
+      )
     );
     inBroker = LendingBroker(payable(address(bProxy)));
 
@@ -312,10 +322,20 @@ contract PositionManagerTest is Test {
 
     // ── Deploy inBrokerSlis ───────────────────────────────────────────────────
     {
-      LendingBroker bSlisImpl = new LendingBroker(address(moolah), address(relayer), address(oracle), address(wbnb));
+      LendingBroker bSlisImpl = new LendingBroker(address(moolah), address(wbnb));
       ERC1967Proxy bSlisProxy = new ERC1967Proxy(
         address(bSlisImpl),
-        abi.encodeWithSelector(LendingBroker.initialize.selector, admin, manager, bot, pauser, address(rateCalc), 100)
+        abi.encodeWithSelector(
+          LendingBroker.initialize.selector,
+          admin,
+          manager,
+          bot,
+          pauser,
+          address(rateCalc),
+          100,
+          address(relayer),
+          address(oracle)
+        )
       );
       inBrokerSlis = LendingBroker(payable(address(bSlisProxy)));
     }
@@ -399,10 +419,20 @@ contract PositionManagerTest is Test {
 
     // ── Deploy inBrokerNative ─────────────────────────────────────────────────
     {
-      LendingBroker bNativeImpl = new LendingBroker(address(moolah), address(relayer), address(oracle), address(wbnb));
+      LendingBroker bNativeImpl = new LendingBroker(address(moolah), address(wbnb));
       ERC1967Proxy bNativeProxy = new ERC1967Proxy(
         address(bNativeImpl),
-        abi.encodeWithSelector(LendingBroker.initialize.selector, admin, manager, bot, pauser, address(rateCalc), 10)
+        abi.encodeWithSelector(
+          LendingBroker.initialize.selector,
+          admin,
+          manager,
+          bot,
+          pauser,
+          address(rateCalc),
+          10,
+          address(relayer),
+          address(oracle)
+        )
       );
       inBrokerNative = LendingBroker(payable(address(bNativeProxy)));
     }