feat: fix rebalance strategy calculation

Author: philbow61

contracts/swap/ReserveLiquidityStrategy.sol

@@ -171,10 +171,10 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
     });
 
     if (priceDirection == PriceDirection.ABOVE_ORACLE) {
-      (collateralOut, inputAmount) = _calculateExpansionAmounts(params, oraclePrice);
+      (collateralOut, inputAmount) = _calculateExpansionAmounts(params, oraclePrice, incentive);
       stableOut = 0;
     } else {
-      (stableOut, inputAmount) = _calculateContractionAmounts(params, oraclePrice);
+      (stableOut, inputAmount) = _calculateContractionAmounts(params, oraclePrice, incentive);
       collateralOut = 0;
     }
 
@@ -190,16 +190,17 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
    */
   function _calculateContractionAmounts(
     RebalanceParams memory params,
-    uint256 oraclePrice
+    uint256 oraclePrice,
+    uint256 incentive
   ) private pure returns (uint256 stableOut, uint256 collateralIn) {
     // Contraction: Sell stables to buy collateral
-    // CollateralIn = (OraclePrice * StableReserve - CollateralReserve) / 2
-    // StablesOut = CollateralIn / OraclePrice
+    // StablesOut = (OraclePrice * StableReserve - CollateralReserve) / (OraclePrice + OraclePrice * (1 - incentive))
+    // CollateralIn = StablesOut * OraclePrice
     uint256 numerator = ((oraclePrice * params.stableReserve) / 1e18) - params.collateralReserve;
-    uint256 denominator = 2;
+    uint256 denominator = oraclePrice + ((oraclePrice * (BPS_SCALE - incentive)) / BPS_SCALE);
 
-    uint256 collateralInRaw = numerator / denominator;
-    uint256 stableOutRaw = (numerator * 1e18) / (denominator * oraclePrice);
+    uint256 stableOutRaw = (numerator * 1e18) / denominator;
+    uint256 collateralInRaw = (stableOutRaw * oraclePrice) / 1e18;
 
     stableOut = stableOutRaw / params.stablePrecision;
     collateralIn = collateralInRaw / params.collateralPrecision;
@@ -214,16 +215,17 @@ contract ReserveLiquidityStrategy is LiquidityStrategy {
    */
   function _calculateExpansionAmounts(
     RebalanceParams memory params,
-    uint256 oraclePrice
+    uint256 oraclePrice,
+    uint256 incentive
   ) private pure returns (uint256 collateralOut, uint256 stablesIn) {
     // Expansion: Sell collateral to buy stables
-    // CollateralOut = (CollateralReserve - OraclePrice * StableReserve) / 2
+    // CollateralOut = (CollateralReserve - OraclePrice * StableReserve) / (1 + 1 - incentive)
     // StablesIn = CollateralOut / OraclePrice
     uint256 numerator = params.collateralReserve - ((oraclePrice * params.stableReserve) / 1e18);
-    uint256 denominator = 2;
+    uint256 denominator = BPS_SCALE * 2 - incentive;
 
-    uint256 collateralOutRaw = numerator / denominator;
-    uint256 stablesInRaw = (numerator * 1e18) / (denominator * oraclePrice);
+    uint256 collateralOutRaw = (numerator * BPS_SCALE) / denominator;
+    uint256 stablesInRaw = (collateralOutRaw * 1e18) / oraclePrice;
 
     collateralOut = collateralOutRaw / params.collateralPrecision;
     stablesIn = stablesInRaw / params.stablePrecision;

script/DeployReserveFPMM.s.sol

@@ -64,9 +64,10 @@ contract DeployReserveFPMM is Script {
     liquidityStrategy.initialize(reserve);
 
     // Add pool to liquidity strategy
-    liquidityStrategy.addPool(cUSDaxlUSDCFPMM, 600, 50);
+    // conservative rebalance incentive until we fixed the precision errors
+    liquidityStrategy.addPool(cUSDaxlUSDCFPMM, 600, 25);
 
-    USDm.initializeV2(address(deployer), address(liquidityStrategy));
+    USDm.initializeV2(address(liquidityStrategy), address(deployer));
 
     FPMM(cUSDaxlUSDCFPMM).setLiquidityStrategy(address(liquidityStrategy), true);
 

test/unit/swap/ReserveLiquidityStrategy.t.sol

@@ -192,7 +192,7 @@ contract ReserveLiquidityStrategyTest is Test {
     uint256 stableReserveInPool = 1000e18; // S
     uint256 collateralReserveInPool = 1000e18; // C
     uint256 oraclePrice = 0.9e18; // P_oracle < 1e18 will make stable * (1-P) > 0
-    uint256 poolPrice = 1.02e18; // P_pool > P_oracle + threshold
+    uint256 poolPrice = 1e18; // P_pool > P_oracle + threshold
     uint256 thresholdBps = 100; // 1%
 
     mockPool.setReserves(stableReserveInPool, collateralReserveInPool);
@@ -203,11 +203,13 @@ contract ReserveLiquidityStrategyTest is Test {
     collateralToken.mint(address(mockPool), 1000e18);
 
     // Pre-calculate expected amounts with these values
-    // Using formula: numerator = C - P * S = 1000e18 - 1000e18*0.9 = 100e18
-    // collateralOut = numerator / 2 = 50e18
-    // stablesIn = (collateralOut * 1e18) / P = (50e18 * 1e18) / 0.9 = 55.555...e18
-    uint256 expectedCollateralOut = 50e18;
-    uint256 expectedStablesIn = 55555555555555555555; // 55.555...e18
+    // Using formula:
+    // numerator = C - P * S = 1000e18 - 1000e18*0.9 = 100e18
+    // denominator = 1 + 1 - incentive = 2 - 0.1 = 1.9
+    // collateralOut = numerator / denominator = 100e18 / 1.9 = 50.251256281407035175
+    // stablesIn = (collateralOut * 1e18) / P = 55.834729201563372416
+    uint256 expectedCollateralOut = 50251256281407035175;
+    uint256 expectedStablesIn = 55834729201563372416; // 55.834...
     uint256 incentiveAmount = (expectedStablesIn * DEFAULT_INCENTIVE) / 10_000;
 
     // Record balances before rebalance
@@ -274,7 +276,7 @@ contract ReserveLiquidityStrategyTest is Test {
     uint256 stableReserveInPool = 1000e18; // S
     uint256 collateralReserveInPool = 950e18; // C < P * S (1000e18)
     uint256 oraclePrice = 1e18; // P_oracle
-    uint256 poolPrice = 0.98e18; // P_pool < P_oracle - threshold
+    uint256 poolPrice = 0.95e18; // P_pool < P_oracle - threshold
     uint256 thresholdBps = 100; // 1%
 
     mockPool.setReserves(stableReserveInPool, collateralReserveInPool);
@@ -290,11 +292,13 @@ contract ReserveLiquidityStrategyTest is Test {
     uint256 reserveCollateralBefore = collateralToken.balanceOf(address(mockReserve));
 
     // Calculate expected amounts
-    // Using formula: numerator = P * S - C = 1e18*1000e18 - 950e18 = 50e18
-    // collateralIn = numerator / 2 = 25e18
-    // stableOut = collateralIn * 1e18 / P = 25e18 / 1e18 = 25e18
-    uint256 expectedCollateralIn = 25e18;
-    uint256 expectedStableOut = 25e18;
+    // Using formula:
+    // numerator = P * S - C = 1000e18 - 950e18 = 50e18
+    // denominator = P + P * (1 - incentive) =  1e18 + 1e18 * (1 - 0.01) = 1.99e18
+    // stableOut = numerator / denominator = 50e18 / 1.99 = 25.125628140703517587
+    // collateralIn = stableOut * 1e18 / P = 25.125628140703517587
+    uint256 expectedCollateralIn = 25125628140703517587;
+    uint256 expectedStableOut = 25125628140703517587;
     uint256 incentiveAmount = (expectedCollateralIn * DEFAULT_INCENTIVE) / 10_000;
 
     // Expect RebalanceInitiated event with calculated amounts
@@ -372,8 +376,9 @@ contract ReserveLiquidityStrategyTest is Test {
 
     // numerator = C_scaled - (P_oracle * S / 1e18)
     uint256 numerator = collateralReserveInPool_scaled - (oraclePrice * stableReserveInPool) / 1e18;
+    uint256 denominator = 10_000 * 2 - DEFAULT_INCENTIVE;
 
-    uint256 collateralOut_scaled = numerator / 2;
+    uint256 collateralOut_scaled = (numerator * 10_000) / denominator;
     uint256 expectedCollateralOut = collateralOut_scaled / 1e12;
     uint256 expectedStablesIn = (collateralOut_scaled * 1e18) / oraclePrice;
     uint256 incentiveAmount = (expectedStablesIn * DEFAULT_INCENTIVE) / 10_000;