Riemann average

src/SpeedJumpIrm.sol

@@ -10,6 +10,10 @@ import {MarketParamsLib} from "../lib/morpho-blue/src/libraries/MarketParamsLib.
 import {Id, MarketParams, Market} from "../lib/morpho-blue/src/interfaces/IMorpho.sol";
 import {MathLib as MorphoMathLib} from "../lib/morpho-blue/src/libraries/MathLib.sol";
 
+/// @dev Number of steps used in the Riemann sum.
+/// @dev 4 steps allows to have a relative error below 30% for 15 days at err=1 or err=-1.
+int256 constant N_STEPS = 4;
+
 /// @title AdaptativeCurveIrm
 /// @author Morpho Labs
 /// @custom:contact security@morpho.org
@@ -120,43 +124,34 @@ contract AdaptativeCurveIrm is IIrm {
 
         int256 startRateAtTarget = rateAtTarget[id];
 
-        // First interaction.
         if (startRateAtTarget == 0) {
+            // First interaction.
             return (uint256(_curve(INITIAL_RATE_AT_TARGET, err)), INITIAL_RATE_AT_TARGET);
         } else {
             // Note that the speed is assumed constant between two interactions, but in theory it increases because of
             // interests. So the rate will be slightly underestimated.
             int256 speed = ADJUSTMENT_SPEED.wMulDown(err);
-
             // market.lastUpdate != 0 because it is not the first interaction with this market.
             // Safe "unchecked" cast because block.timestamp - market.lastUpdate <= block.timestamp <= type(int256).max.
             int256 elapsed = int256(block.timestamp - market.lastUpdate);
             int256 linearAdaptation = speed * elapsed;
-            int256 adaptationMultiplier = MathLib.wExp(linearAdaptation);
+
             // endRateAtTarget is bounded between MIN_RATE_AT_TARGET and MAX_RATE_AT_TARGET.
             int256 endRateAtTarget =
-                startRateAtTarget.wMulDown(adaptationMultiplier).bound(MIN_RATE_AT_TARGET, MAX_RATE_AT_TARGET);
-            int256 endBorrowRate = _curve(endRateAtTarget, err);
-
-            // Then we compute the average rate over the period.
-            // Note that startBorrowRate is defined in the computations below.
-            // avgBorrowRate = 1 / elapsed * ∫ startBorrowRate * exp(speed * t) dt between 0 and elapsed
-            //               = startBorrowRate * (exp(linearAdaptation) - 1) / linearAdaptation
-            //               = (endBorrowRate - startBorrowRate) / linearAdaptation
-            // And for linearAdaptation around zero: avgBorrowRate ~ startBorrowRate = endBorrowRate.
-            // Also, when it is the first interaction (rateAtTarget = 0).
-            int256 avgBorrowRate;
-            if (linearAdaptation == 0) {
-                avgBorrowRate = endBorrowRate;
-            } else {
-                int256 startBorrowRate = _curve(startRateAtTarget, err);
-                avgBorrowRate = (endBorrowRate - startBorrowRate).wDivDown(linearAdaptation);
+                startRateAtTarget.wMulDown(MathLib.wExp(linearAdaptation)).bound(MIN_RATE_AT_TARGET, MAX_RATE_AT_TARGET);
+
+            // Then we compute the average rate over the period, with a Riemann sum.
+            // We omit the multiplication by the rectangle length because we would divide everything by the total length
+            // at the end, because we want to compute the average and not the integral.
+            int256 sum;
+            int256 step = linearAdaptation / N_STEPS;
+            for (int256 k = 1; k <= N_STEPS; k++) {
+                sum += startRateAtTarget.wMulDown(MathLib.wExp(step * k)).bound(MIN_RATE_AT_TARGET, MAX_RATE_AT_TARGET);
             }
+            int256 averageRateAtTarget = sum / N_STEPS;
 
-            // avgBorrowRate is non negative because:
-            // - endBorrowRate >= 0 because endRateAtTarget >= MIN_RATE_AT_TARGET.
-            // - linearAdaptation < 0 <=> adaptationMultiplier <= 1 <=> endBorrowRate <= startBorrowRate.
-            return (uint256(avgBorrowRate), endRateAtTarget);
+            // avgBorrowRate is non negative because averageRateAtTarget is non negative.
+            return (uint256(_curve(averageRateAtTarget, err)), endRateAtTarget);
         }
     }
 

test/SpeedJumpIrmTest.sol

@@ -76,22 +76,22 @@ contract AdaptativeCurveIrmTest is Test {
 
         market.totalBorrowAssets = 1 ether;
         market.totalSupplyAssets = 1 ether;
-        market.lastUpdate = uint128(block.timestamp - 30 days);
+        market.lastUpdate = uint128(block.timestamp - 5 days);
 
-        // (exp((50/365)*30) ~= 61.
+        // (exp((50/365)*5) ~= 1.9836.
         assertApproxEqRel(
             irm.borrowRateView(marketParams, market),
-            uint256((INITIAL_RATE_AT_TARGET * 4).wMulDown((61 ether - 1 ether) * WAD / (ADJUSTMENT_SPEED * 30 days))),
+            uint256((INITIAL_RATE_AT_TARGET * 4).wMulDown((1.9836 ether - 1 ether) * WAD / (ADJUSTMENT_SPEED * 5 days))),
             0.1 ether
         );
-        // The average value of exp((50/365)*30) between 0 and 30 is approx. 14.58.
+        // The average value of exp((50/365)*x) between 0 and 5 is approx. 1.4361.
         assertApproxEqRel(
             irm.borrowRateView(marketParams, market),
-            uint256((INITIAL_RATE_AT_TARGET * 4).wMulDown(14.58 ether)),
+            uint256((INITIAL_RATE_AT_TARGET * 4).wMulDown(1.4361 ether)),
             0.1 ether
         );
-        // Expected rate: 58%.
-        assertApproxEqRel(irm.borrowRateView(marketParams, market), uint256(0.58 ether) / 365 days, 0.1 ether);
+        // Expected rate: 5.744%.
+        assertApproxEqRel(irm.borrowRateView(marketParams, market), uint256(0.05744 ether) / 365 days, 0.1 ether);
     }
 
     function testRateAfterUtilizationZero() public {
@@ -101,24 +101,24 @@ contract AdaptativeCurveIrmTest is Test {
 
         market.totalBorrowAssets = 0 ether;
         market.totalSupplyAssets = 1 ether;
-        market.lastUpdate = uint128(block.timestamp - 30 days);
+        market.lastUpdate = uint128(block.timestamp - 5 days);
 
-        // (exp((-50/365)*30) ~= 0.016.
+        // (exp((-50/365)*5) ~= 0.5041.
         assertApproxEqRel(
             irm.borrowRateView(marketParams, market),
             uint256(
-                (INITIAL_RATE_AT_TARGET / 4).wMulDown((0.016 ether - 1 ether) * WAD / (-ADJUSTMENT_SPEED * 30 days))
+                (INITIAL_RATE_AT_TARGET / 4).wMulDown((0.5041 ether - 1 ether) * WAD / (-ADJUSTMENT_SPEED * 5 days))
             ),
             0.1 ether
         );
-        // The average value of exp((-50/365*30)) between 0 and 30 is approx. 0.239.
+        // The average value of exp((-50/365*x)) between 0 and 5 is approx. 0.7240.
         assertApproxEqRel(
             irm.borrowRateView(marketParams, market),
-            uint256((INITIAL_RATE_AT_TARGET / 4).wMulDown(0.23 ether)),
+            uint256((INITIAL_RATE_AT_TARGET / 4).wMulDown(0.724 ether)),
             0.1 ether
         );
-        // Expected rate: 0.057%.
-        assertApproxEqRel(irm.borrowRateView(marketParams, market), uint256(0.00057 ether) / 365 days, 0.1 ether);
+        // Expected rate: 0.181%.
+        assertApproxEqRel(irm.borrowRateView(marketParams, market), uint256(0.00181 ether) / 365 days, 0.1 ether);
     }
 
     function testFirstBorrowRate(Market memory market) public {
@@ -163,7 +163,7 @@ contract AdaptativeCurveIrmTest is Test {
 
         vm.assume(market1.totalBorrowAssets > 0);
         vm.assume(market1.totalSupplyAssets >= market1.totalBorrowAssets);
-        market1.lastUpdate = uint128(bound(market1.lastUpdate, 0, block.timestamp - 1));
+        market1.lastUpdate = uint128(bound(market1.lastUpdate, block.timestamp - 5 days, block.timestamp - 1));
 
         int256 expectedRateAtTarget = _expectedRateAtTarget(marketParams.id(), market1);
         uint256 expectedAvgRate = _expectedAvgRate(marketParams.id(), market1);
@@ -172,7 +172,7 @@ contract AdaptativeCurveIrmTest is Test {
         uint256 borrowRate = irm.borrowRate(marketParams, market1);
 
         assertEq(borrowRateView, borrowRate, "borrowRateView");
-        assertApproxEqRel(borrowRate, expectedAvgRate, 0.01 ether, "avgBorrowRate");
+        assertApproxEqRel(borrowRate, expectedAvgRate, 0.1 ether, "avgBorrowRate");
         assertApproxEqRel(irm.rateAtTarget(marketParams.id()), expectedRateAtTarget, 0.001 ether, "rateAtTarget");
     }
 
@@ -203,7 +203,7 @@ contract AdaptativeCurveIrmTest is Test {
 
         market1.totalBorrowAssets = market0.totalBorrowAssets;
         market1.totalSupplyAssets = market0.totalSupplyAssets;
-        market1.lastUpdate = uint128(bound(market1.lastUpdate, 0, block.timestamp - 1));
+        market1.lastUpdate = uint128(bound(market1.lastUpdate, block.timestamp - 5 days, block.timestamp - 1));
 
         int256 expectedRateAtTarget = _expectedRateAtTarget(marketParams.id(), market1);
         uint256 expectedAvgRate = _expectedAvgRate(marketParams.id(), market1);
@@ -212,7 +212,7 @@ contract AdaptativeCurveIrmTest is Test {
         uint256 borrowRate = irm.borrowRate(marketParams, market1);
 
         assertEq(borrowRateView, borrowRate, "borrowRateView");
-        assertApproxEqRel(borrowRate, expectedAvgRate, 0.01 ether, "avgBorrowRate");
+        assertApproxEqRel(borrowRate, expectedAvgRate, 0.1 ether, "avgBorrowRate");
         assertApproxEqRel(irm.rateAtTarget(marketParams.id()), expectedRateAtTarget, 0.001 ether, "rateAtTarget");
     }