Add fee tests

foundry.toml

@@ -9,13 +9,6 @@ fs_permissions = [
     { access = "read", path = "./lib/morpho-blue/out/"}
 ]
 
-[profile.default.fuzz]
-runs = 32
-
-[profile.default.invariant]
-runs = 16
-depth = 4
-
 [profile.default.rpc_endpoints]
 mainnet = "https://eth-mainnet.g.alchemy.com/v2/${ALCHEMY_KEY}"
 tenderly = "https://rpc.tenderly.co/fork/${TENDERLY_FORK_ID}"

src/MetaMorpho.sol

@@ -156,6 +156,7 @@ contract MetaMorpho is ERC4626, Ownable2Step, IMetaMorpho {
 
     function setFeeRecipient(address newFeeRecipient) external onlyOwner {
         require(newFeeRecipient != feeRecipient, ErrorsLib.ALREADY_SET);
+        require(newFeeRecipient != address(0) || fee == 0, ErrorsLib.ZERO_FEE_RECIPIENT);
 
         // Accrue interest to the previous fee recipient set before changing it.
         _updateLastTotalAssets(_accrueFee());

src/libraries/ErrorsLib.sol

@@ -33,4 +33,6 @@ library ErrorsLib {
     string internal constant TIMELOCK_EXPIRATION_EXCEEDED = "timelock expiration exceeded";
 
     string internal constant MAX_QUEUE_SIZE_EXCEEDED = "max queue size exceeded";
+
+    string internal constant ZERO_FEE_RECIPIENT = "fee recipient is zero";
 }

src/mocks/IrmMock.sol

@@ -9,15 +9,17 @@ import {MathLib} from "@morpho-blue/libraries/MathLib.sol";
 contract IrmMock is IIrm {
     using MathLib for uint128;
 
-    function borrowRateView(MarketParams memory, Market memory market) public pure returns (uint256) {
-        uint256 utilization = market.totalBorrowAssets.wDivDown(market.totalSupplyAssets);
+    uint256 public apr;
 
-        // Divide by the number of seconds in a year.
-        // This is a very simple model where x% utilization corresponds to x% APR.
-        return utilization / 365 days;
+    function setApr(uint256 newApr) external {
+        apr = newApr;
     }
 
-    function borrowRate(MarketParams memory marketParams, Market memory market) external pure returns (uint256) {
+    function borrowRateView(MarketParams memory, Market memory) public view returns (uint256) {
+        return apr / 365 days;
+    }
+
+    function borrowRate(MarketParams memory marketParams, Market memory market) external view returns (uint256) {
         return borrowRateView(marketParams, market);
     }
 }

test/forge/FeeTest.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import "./helpers/BaseTest.sol";
+
+contract FeeTest is BaseTest {
+    using Math for uint256;
+    using MathLib for uint256;
+    using MarketParamsLib for MarketParams;
+
+    function setUp() public override {
+        super.setUp();
+
+        _setCap(allMarkets[0], CAP);
+    }
+
+    function _feeShares(uint256 totalAssetsBefore) internal view returns (uint256) {
+        uint256 totalAssetsAfter = vault.totalAssets();
+        uint256 interest = totalAssetsAfter - totalAssetsBefore;
+        uint256 feeAmount = interest.wMulDown(FEE);
+
+        return feeAmount.mulDiv(
+            vault.totalSupply() + 10 ** DECIMALS_OFFSET, totalAssetsAfter - feeAmount + 1, Math.Rounding.Down
+        );
+    }
+
+    function testLastTotalAssets(uint256 deposited) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+    }
+
+    function testAccrueFeeWithinABlock(uint256 deposited, uint256 withdrawn) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        withdrawn = bound(withdrawn, MIN_TEST_ASSETS, deposited);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        vm.prank(ONBEHALF);
+        vault.withdraw(withdrawn, RECEIVER, ONBEHALF);
+
+        assertEq(vault.balanceOf(FEE_RECIPIENT), 0, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testDepositAccrueFee(uint256 deposited, uint256 assets, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        assets = bound(assets, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        blocks = _boundBlocks(blocks);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        borrowableToken.setBalance(SUPPLIER, assets);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(assets, ONBEHALF);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testMintAccrueFee(uint256 deposited, uint256 assets, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        assets = bound(assets, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        blocks = _boundBlocks(blocks);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        uint256 shares = vault.convertToShares(assets);
+
+        borrowableToken.setBalance(SUPPLIER, assets);
+
+        vm.prank(SUPPLIER);
+        vault.mint(shares, ONBEHALF);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testRedeemAccrueFee(uint256 deposited, uint256 withdrawn, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        withdrawn = bound(withdrawn, MIN_TEST_ASSETS, deposited);
+        blocks = _boundBlocks(blocks);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        uint256 shares = vault.convertToShares(withdrawn);
+
+        vm.prank(ONBEHALF);
+        vault.redeem(shares, RECEIVER, ONBEHALF);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testWithdrawAccrueFee(uint256 deposited, uint256 withdrawn, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        withdrawn = bound(withdrawn, MIN_TEST_ASSETS, deposited);
+        blocks = _boundBlocks(blocks);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        vm.prank(ONBEHALF);
+        vault.withdraw(withdrawn, RECEIVER, ONBEHALF);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testSetFeeAccrueFee(uint256 deposited, uint256 fee, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        fee = bound(fee, 0, WAD);
+        blocks = _boundBlocks(blocks);
+
+        vm.assume(fee != FEE);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        _setFee(fee);
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+    }
+
+    function testSetFeeRecipientAccrueFee(uint256 deposited, uint256 blocks) public {
+        deposited = bound(deposited, MIN_TEST_ASSETS, MAX_TEST_ASSETS);
+        blocks = _boundBlocks(blocks);
+
+        borrowableToken.setBalance(SUPPLIER, deposited);
+
+        vm.prank(SUPPLIER);
+        vault.deposit(deposited, ONBEHALF);
+
+        uint256 totalAssetsBefore = vault.totalAssets();
+
+        _forward(blocks);
+
+        uint256 feeShares = _feeShares(totalAssetsBefore);
+
+        vm.prank(OWNER);
+        vault.setFeeRecipient(address(1));
+
+        assertEq(vault.lastTotalAssets(), vault.totalAssets(), "lastTotalAssets");
+        assertEq(vault.balanceOf(FEE_RECIPIENT), feeShares, "vault.balanceOf(FEE_RECIPIENT)");
+        assertEq(vault.balanceOf(address(1)), 0, "vault.balanceOf(address(1))");
+    }
+}