🚧 setup testing

Author: acollette

src/lockers/AaveLocker.sol

@@ -74,9 +74,11 @@ contract AaveV3Locker is AbstractLocker {
         // Calculate current value of position in underlying token.
         uint256 withdrawableBalance = getTotalValue(asset);
 
-        // The yield is the difference between current claimable balance and total deposited.
         // Cache value
         uint256 totalDeposited_ = totalDeposited;
+        totalDeposited = 0;
+
+        // The yield is the difference between current claimable balance and total deposited.
         yield = withdrawableBalance > totalDeposited_ ? withdrawableBalance - totalDeposited_ : 0;
 
         uint256 totalWithdrawn = AAVE_POOL.withdraw(asset, type(uint256).max, msg.sender);

src/token/EurB.sol

@@ -10,6 +10,7 @@ import {IERC20} from "../../lib/openzeppelin-contracts/contracts/interfaces/IERC
 import {ISafe} from "./interfaces/ISafe.sol";
 import {ILocker} from "../lockers/interfaces/ILocker.sol";
 import {Ownable} from "../../lib/openzeppelin-contracts/contracts/access/Ownable.sol";
+import {ReentrancyGuard} from "../../lib/solmate/src/utils/ReentrancyGuard.sol";
 import {SafeERC20} from "../../lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
 import {Storage} from "./Storage.sol";
 
@@ -22,6 +23,7 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
     ////////////////////////////////////////////////////////////// */
 
     error IsNotALocker();
+    error IsActiveLocker();
     error LengthMismatch();
     error LockerNotPrivate();
     error MaxCommissionsDepth();
@@ -40,6 +42,16 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
                                 MODIFIERS
     ////////////////////////////////////////////////////////////// */
 
+    modifier nonReentrant() {
+        require(locked == 1, "REENTRANCY");
+
+        locked = 2;
+
+        _;
+
+        locked = 1;
+    }
+
     /* //////////////////////////////////////////////////////////////
                                 CONSTRUCTOR
     ////////////////////////////////////////////////////////////// */
@@ -115,8 +127,12 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
                          YIELD LOCKERS LOGIC
     ////////////////////////////////////////////////////////////// */
 
-    function syncAll() external {
+    /**
+     * @notice Synchronizes all yield lockers by adjusting balances based on weights and idle ratio.
+     */
+    function syncAll() external nonReentrant {
         if (block.timestamp < lastSyncTime + 1 days) revert SyncIntervalNotMet();
+        lastSyncTime = block.timestamp;
 
         // Cache values.
         uint256 BIPS_ = BIPS;
@@ -154,7 +170,6 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         }
 
         // Get total amount that should be deposited in lockers (non-idle).
-        // Note : check if ok to keep same totalSupply here (think should be ok)
         uint256 totalToInvest = totalSupplyExclPrivate.mulDivDown(BIPS_ - idleRatio, BIPS_);
 
         // We use weights.length as those should always sum to BIPS (see setWeights()).
@@ -164,7 +179,6 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
             uint256 currentBalance = ILocker(lockers[i]).totalDeposited();
 
             if (currentBalance < targetBalance) {
-                // Note : use batchApprove.
                 uint256 toDeposit = targetBalance - currentBalance;
                 IERC20(underlying_).approve(lockers[i], toDeposit);
                 // Don't revert if the call fails, continue.
@@ -180,7 +194,10 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         }
     }
 
-    // Note : It should mint the yield in underlying token and distribute to treasury
+    /**
+     * @notice Collects yield from all yield lockers and mints it to the treasury.
+     * @return yield The total yield collected.
+     */
     function collectYield() external returns (uint256 yield) {
         if (block.timestamp - lastYieldClaim < yieldInterval) revert YieldIntervalNotMet();
 
@@ -209,11 +226,19 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         treasury = treasury_;
     }
 
+    /**
+     * @notice Adds a new yield locker to the system.
+     * @param locker The address of the locker to add.
+     */
     function addYieldLocker(address locker) external onlyOwner {
         if (yieldLockers.length == MAX_YIELD_LOCKERS) revert MaxYieldLockers();
         yieldLockers.push(locker);
     }
 
+    /**
+     * @notice Removes a yield locker from the system, withdrawing its balance.
+     * @param locker The address of the locker to remove.
+     */
     function removeYieldLocker(address locker) external onlyOwner {
         // Cache values
         address[] memory yieldLockers_ = yieldLockers;
@@ -248,6 +273,10 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         lockersWeights.pop();
     }
 
+    /**
+     * @notice Sets the weights for yield lockers.
+     * @param newLockersWeights The new weights for each locker.
+     */
     // Note : Double check no issue if idle set to max vs lockers
     function setWeights(uint256[] memory newLockersWeights) external onlyOwner {
         if (newLockersWeights.length != yieldLockers.length) revert LengthMismatch();
@@ -259,11 +288,19 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         lockersWeights = newLockersWeights;
     }
 
+    /**
+     * @notice Sets a new idle ratio for the system.
+     * @param newRatio The new idle ratio.
+     */
     function setIdleRatio(uint256 newRatio) external onlyOwner {
         if (newRatio > BIPS) revert MaxRatio();
         idleRatio = newRatio;
     }
 
+    /**
+     * @notice Sets the interval for yield collection.
+     * @param yieldInterval_ The new yield interval in seconds.
+     */
     function setYieldInterval(uint256 yieldInterval_) external onlyOwner {
         if (yieldInterval_ > 30 days) revert MaxYieldInterval();
         yieldInterval = yieldInterval_;
@@ -273,10 +310,22 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
                     PRIVATE YIELD LOCKERS LOGIC
     ////////////////////////////////////////////////////////////// */
 
+    /**
+     * @notice Marks an address as a private locker.
+     * @param locker The address of the locker to mark as private.
+     */
     function addPrivateLocker(address locker) external onlyOwner {
+        for (uint256 i; i < yieldLockers.length; ++i) {
+            if (locker == yieldLockers[i]) revert IsActiveLocker();
+        }
         isPrivateLocker[locker] = true;
     }
 
+    /**
+     * @notice Deposits an amount into a private locker.
+     * @param locker The address of the private locker.
+     * @param amount The amount to deposit.
+     */
     function depositInPrivateLocker(address locker, uint256 amount) external onlyOwner {
         if (isPrivateLocker[locker] == false) revert LockerNotPrivate();
 
@@ -285,8 +334,26 @@ contract EurB is ERC20Wrapper, Ownable, Storage {
         ILocker(locker).deposit(address(underlying()), amount);
     }
 
-    function collectYieldFromPrivateLocker(address locker) external onlyOwner {
+    /**
+     * @notice Collects yield from a private locker.
+     * @param locker The address of the private locker.
+     */
+    function collectYieldFromPrivateLocker(address locker) external onlyOwner returns (uint256 yield) {
         if (isPrivateLocker[locker] == false) revert LockerNotPrivate();
+
+        // Cache value
+        address underlying_ = address(underlying());
+        // Get total balance before collecting yield.
+        uint256 initBalance = IERC20(underlying_).balanceOf(address(this));
+        ILocker(locker).collectYield(underlying_);
+        // Calculate yield collected.
+        uint256 newBalance = IERC20(underlying_).balanceOf(address(this));
+
+        yield = newBalance > initBalance ? newBalance - initBalance : 0;
+        if (yield > 0) {
+            // Mint the yield generated to the treasury.
+            _mint(treasury, yield);
+        }
     }
     // Note : Do we put a recover function (yes with limited withdrawable assets) ?
 }

src/token/Storage.sol

@@ -19,6 +19,8 @@ contract Storage {
                                 STORAGE
     ////////////////////////////////////////////////////////////// */
 
+    // Reentrancy guard.
+    uint256 internal locked = 1;
     // The address of the CardFactory contract.
     ICardFactory public cardFactory;
     // The address of the treasury

test/Base.t.sol

@@ -33,7 +33,8 @@ abstract contract Base_Test is Test {
         users = Users({
             dao: createUser("dao"),
             treasury: createUser("treasury"),
-            unprivilegedAddress: createUser("unprivilegedAddress")
+            unprivilegedAddress: createUser("unprivilegedAddress"),
+            tokenHolder: createUser("tokenHolder")
         });
     }
 

test/fuzz/EurB/_EurB.fuzz.t.sol

@@ -1,16 +1,27 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.22;
 
+import {FixedPointMathLib} from "../../../lib/solmate/src/utils/FixedPointMathLib.sol";
 import {Fuzz_Test} from "../Fuzz.t.sol";
+import {LockerMock} from "../../utils/mocks/LockerMock.sol";
 
 /**
  * @notice Common logic needed by all "EurB" fuzz tests.
  */
 abstract contract EurB_Fuzz_Test is Fuzz_Test {
+    using FixedPointMathLib for uint256;
     /* ///////////////////////////////////////////////////////////////
                              VARIABLES
     /////////////////////////////////////////////////////////////// */
 
+    struct StateVars {
+        uint256 idleRatio;
+        uint256 idleBalance;
+        uint256 lastSyncTime;
+        uint256 lastYieldClaim;
+        uint256 yieldInterval;
+    }
+
     /* ///////////////////////////////////////////////////////////////
                             TEST CONTRACTS
     /////////////////////////////////////////////////////////////// */
@@ -26,4 +37,80 @@ abstract contract EurB_Fuzz_Test is Fuzz_Test {
     /* ///////////////////////////////////////////////////////////////
                             HELPER FUNCTIONS
     /////////////////////////////////////////////////////////////// */
+
+    function setStateOfLockers(
+        uint256 numberOfLockers,
+        uint256[5] memory lockerDeposits,
+        uint256[5] memory lockerYields,
+        uint256[5] memory lockerWeights
+    ) public {
+        // Given: Deploy lockers and add them to EurB.
+        numberOfLockers = bound(numberOfLockers, 1, 5);
+
+        uint256 sumOfLockerWeights;
+        uint256[] memory lockerWeights_ = new uint256[](numberOfLockers);
+        vm.startPrank(users.dao);
+        for (uint256 i; i < numberOfLockers; ++i) {
+            // Add locker to EURB.
+            LockerMock newLocker = new LockerMock(address(EURB));
+            EURB.addYieldLocker(address(newLocker));
+
+            // Set weights.
+            if (sumOfLockerWeights == BIPS) {
+                lockerWeights_[i] = 0;
+            } else {
+                if (i == numberOfLockers - 1) {
+                    lockerWeights_[i] = BIPS - sumOfLockerWeights;
+                } else {
+                    lockerWeights_[i] = bound(lockerWeights[i], 0, BIPS - sumOfLockerWeights);
+                }
+            }
+
+            // Deposit in lockers.
+            lockerDeposits[i] = bound(lockerDeposits[i], 0, type(uint96).max);
+            // Mint to locker and dao.
+            EURE.mint(address(newLocker), lockerDeposits[i]);
+            EURB.mint(users.dao, lockerDeposits[i]);
+            // Increase locker deposit.
+            newLocker.increaseDeposits(lockerDeposits[i]);
+            // Send the yield to the locker.
+            // Yield should be max 20 % of deposited value.
+            lockerYields[i] = bound(lockerYields[i], 0, lockerDeposits[i].mulDivDown(2_000, BIPS));
+            // Mint the yield to the locker.
+            EURE.mint(address(newLocker), lockerYields[i]);
+        }
+        // Sum of weights should be equal to BIPS.
+        assertEq(sumOfLockerWeights, BIPS);
+        // Set weights.
+        EURB.setWeights(lockerWeights_);
+        vm.stopPrank();
+    }
+
+    function setStateVars(StateVars memory stateVars) public {
+        vm.startPrank(users.dao);
+
+        // Set idle ratio.
+        stateVars.idleRatio = bound(stateVars.idleRatio, 0, BIPS);
+        EURB.setIdleRatio(stateVars.idleRatio);
+
+        // Set last sync time.
+        stateVars.lastSyncTime = bound(stateVars.lastSyncTime, 0, block.timestamp - 1 days - 1);
+        EURB.setLastSyncTime(stateVars.lastSyncTime);
+
+        // Set last yield interval.
+        stateVars.yieldInterval = bound(stateVars.yieldInterval, 0, 30 days);
+        EURB.setYieldInterval(stateVars.yieldInterval);
+
+        // Set last yield claim.
+        stateVars.lastYieldClaim = bound(stateVars.lastYieldClaim, 0, block.timestamp - stateVars.yieldInterval - 1);
+        EURB.setLastYieldClaim(stateVars.lastYieldClaim);
+
+        // Set idle balance.
+        stateVars.idleBalance = bound(stateVars.idleBalance, 0, type(uint96).max);
+        EURE.mint(users.dao, stateVars.idleBalance);
+        vm.startPrank(users.dao);
+        EURB.depositFor(users.dao, stateVars.idleBalance);
+
+        vm.stopPrank();
+    }
 }

test/fuzz/Fuzz.t.sol

@@ -6,7 +6,9 @@ import {CardFactoryMock} from "../utils/mocks/CardFactoryMock.sol";
 import {CommissionModule} from "../../src/modules/CommissionModule.sol";
 import {ERC20Mock} from "../utils/mocks/ERC20Mock.sol";
 import {EurB} from "../../src/token/EurB.sol";
+import {EurBExtension} from "../utils/extensions/EurBExtension.sol";
 import {IERC20} from "../../lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol";
+import {LockerMock} from "../utils/mocks/LockerMock.sol";
 import {SafeMock} from "../utils/mocks/SafeMock.sol";
 
 /**
@@ -17,19 +19,25 @@ abstract contract Fuzz_Test is Base_Test {
                                      VARIABLES
     //////////////////////////////////////////////////////////////////////////*/
 
+    uint256 public BIPS = 10_000;
+    // Unix timestamps of 12 November 2024
+    uint256 public DATE_12_NOV_24 = 1731418562;
+
     /*//////////////////////////////////////////////////////////////////////////
                                    TEST CONTRACTS
     //////////////////////////////////////////////////////////////////////////*/
 
     CardFactoryMock public CARD_FACTORY;
     CommissionModule public COMMISSION_MODULE;
     ERC20Mock public EURE;
-    EurB public EURB;
+    EurBExtension public EURB;
 
     SafeMock public SAFE1;
     SafeMock public SAFE2;
     SafeMock public SAFE3;
 
+    LockerMock[] public yieldLockers;
+
     /*//////////////////////////////////////////////////////////////////////////
                                   SET-UP FUNCTION
     //////////////////////////////////////////////////////////////////////////*/
@@ -38,14 +46,15 @@ abstract contract Fuzz_Test is Base_Test {
         Base_Test.setUp();
 
         // Warp to have a timestamp of at least two days old.
-        vm.warp(2 days);
+        vm.warp(DATE_12_NOV_24);
 
         // Deploy contracts.
         vm.startPrank(users.dao);
         COMMISSION_MODULE = new CommissionModule();
         CARD_FACTORY = new CardFactoryMock(address(COMMISSION_MODULE));
+        CARD_FACTORY.setCommissionHookModule(address(COMMISSION_MODULE));
         EURE = new ERC20Mock("Monerium EUR", "EURE", 18);
-        EURB = new EurB(IERC20(address(EURE)), users.treasury, address(CARD_FACTORY));
+        EURB = new EurBExtension(IERC20(address(EURE)), users.treasury, address(CARD_FACTORY));
 
         SAFE1 = new SafeMock();
         SAFE2 = new SafeMock();

test/utils/Types.sol

@@ -5,4 +5,5 @@ struct Users {
     address payable dao;
     address payable treasury;
     address payable unprivilegedAddress;
+    address payable tokenHolder;
 }