@ensuro/core 2.0.0-beta1 → 2.0.0-beta11

package/contracts/EToken.sol

@@ -1,13 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
 import {Reserve} from "./Reserve.sol";
 import {IEToken} from "./interfaces/IEToken.sol";
-import {IPolicyPoolConfig} from "./interfaces/IPolicyPoolConfig.sol";
-import {WadRayMath} from "./WadRayMath.sol";
+import {IAccessManager} from "./interfaces/IAccessManager.sol";
+import {IPolicyPoolComponent} from "./interfaces/IPolicyPoolComponent.sol";
+import {ILPWhitelist} from "./interfaces/ILPWhitelist.sol";
+import {IAssetManager} from "./interfaces/IAssetManager.sol";
+import {WadRayMath} from "./dependencies/WadRayMath.sol";
 import {TimeScaled} from "./TimeScaled.sol";
 
 /**
@@ -24,8 +30,14 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
   using WadRayMath for uint256;
   using TimeScaled for TimeScaled.ScaledAmount;
   using SafeERC20 for IERC20Metadata;
+  using SafeCast for uint256;
 
-  uint256 internal constant SECONDS_PER_YEAR = 365 days;
+  uint256 internal constant FOUR_DECIMAL_TO_WAD = 1e14;
+  uint16 internal constant HUNDRED_PERCENT = 1e4;
+  uint16 internal constant MAX_UR_MIN = 5e3; // 50% - Minimum value for Max Utilization Rate
+  uint16 internal constant LIQ_REQ_MIN = 8e3; // 80%
+  uint16 internal constant LIQ_REQ_MAX = 13e3; // 130%
+  uint16 internal constant INT_LOAN_IR_MAX = 5e3; // 50% - Maximum value for InternalLoan interest rate
 
   // Attributes taken from ERC20
   mapping(address => uint256) private _balances;
@@ -52,13 +64,17 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     uint16 minUtilizationRate; // Min utilization rate, to reject deposits that leave UR under this value - 4 decimals
     uint16 maxUtilizationRate; // Max utilization rate, to reject lockScr that leave UR above this value - 4 decimals
     uint16 internalLoanInterestRate; // Annualized interest rate charged to internal borrowers (premiums accounts) - 4dec
+    ILPWhitelist whitelist; // Whitelist for deposits and transfers
   }
 
   PackedParams internal _params;
 
+  IAssetManager internal _assetManager;
+
   event InternalLoan(address indexed borrower, uint256 value, uint256 amountAsked);
   event InternalLoanRepaid(address indexed borrower, uint256 value);
-  event PoolBorrowerAdded(address borrower);
+  event InternalBorrowerAdded(address indexed borrower);
+  event InternalBorrowerRemoved(address indexed borrower, uint256 defaultedDebt);
 
   modifier onlyBorrower() {
     require(_loans[_msgSender()].scale != 0, "The caller must be a borrower");
@@ -82,7 +98,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     uint256 maxUtilizationRate_,
     uint256 internalLoanInterestRate_
   ) public initializer {
-    __PolicyPoolComponent_init();
+    __Reserve_init();
     __EToken_init_unchained(name_, symbol_, maxUtilizationRate_, internalLoanInterestRate_);
   }
 
@@ -92,7 +108,9 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     string memory symbol_,
     uint256 maxUtilizationRate_,
     uint256 internalLoanInterestRate_
-  ) internal initializer {
+  ) internal onlyInitializing {
+    require(bytes(name_).length > 0, "EToken: name cannot be empty");
+    require(bytes(symbol_).length > 0, "EToken: symbol cannot be empty");
     _name = name_;
     _symbol = symbol_;
     _tsScaled.init();
@@ -102,28 +120,52 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
       tokenInterestRate: 0
     }); */
     _params = PackedParams({
-      maxUtilizationRate: uint16(maxUtilizationRate_ / 1e14),
-      liquidityRequirement: 1e4,
+      maxUtilizationRate: _wadTo4(maxUtilizationRate_),
+      liquidityRequirement: HUNDRED_PERCENT,
       minUtilizationRate: 0,
-      internalLoanInterestRate: uint16(internalLoanInterestRate_ / 1e14)
+      internalLoanInterestRate: _wadTo4(internalLoanInterestRate_),
+      whitelist: ILPWhitelist(address(0))
     });
 
     _validateParameters();
   }
 
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   */
+  function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+    return
+      super.supportsInterface(interfaceId) ||
+      interfaceId == type(IERC20).interfaceId ||
+      interfaceId == type(IERC20Metadata).interfaceId ||
+      interfaceId == type(IEToken).interfaceId;
+  }
+
   // runs validation on EToken parameters
   function _validateParameters() internal view override {
     require(
-      _params.liquidityRequirement >= 8e3 && _params.liquidityRequirement <= 13e3,
+      _params.liquidityRequirement >= LIQ_REQ_MIN && _params.liquidityRequirement <= LIQ_REQ_MAX,
       "Validation: liquidityRequirement must be [0.8, 1.3]"
     );
     require(
-      _params.maxUtilizationRate >= 5e3 && _params.maxUtilizationRate <= 1e4,
+      _params.maxUtilizationRate >= MAX_UR_MIN && _params.maxUtilizationRate <= HUNDRED_PERCENT,
       "Validation: maxUtilizationRate must be [0.5, 1]"
     );
-    require(_params.minUtilizationRate <= 1e4, "Validation: minUtilizationRate must be [0, 1]");
     require(
-      _params.internalLoanInterestRate <= 5e3,
+      _params.minUtilizationRate <= HUNDRED_PERCENT,
+      "Validation: minUtilizationRate must be [0, 1]"
+    );
+    /*
+     * We don't validate minUtilizationRate < maxUtilizationRate because the opposite is valid too.
+     * These limits aren't strong limits on the values the utilization rate can take, but instead they are
+     * limits on specific operations.
+     * `minUtilizationRate` is used to avoid new deposits to dilute the yields of existing LPs, but it doesn't
+     * prevent the UR from going down in other operations (`unlockScr` for example).
+     * `maxUtilizationRate` is used to prevent selling more coverage when UR is too high, only checked on `lockScr`
+     * operations, but not in withdrawals or other operations.
+     */
+    require(
+      _params.internalLoanInterestRate <= INT_LOAN_IR_MAX,
       "Validation: internalLoanInterestRate must be <= 50%"
     );
   }
@@ -234,15 +276,34 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     address recipient,
     uint256 amount
   ) public virtual override returns (bool) {
+    address spender = _msgSender();
+    _spendAllowance(sender, spender, amount);
     _transfer(sender, recipient, amount);
-
-    uint256 currentAllowance = _allowances[sender][_msgSender()];
-    require(currentAllowance >= amount, "EToken: transfer amount exceeds allowance");
-    _approve(sender, _msgSender(), currentAllowance - amount);
-
     return true;
   }
 
+  /**
+   * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
+   *
+   * Does not update the allowance amount in case of infinite allowance.
+   * Revert if not enough allowance is available.
+   *
+   * Might emit an {Approval} event.
+   */
+  function _spendAllowance(
+    address owner,
+    address spender,
+    uint256 amount
+  ) internal virtual {
+    uint256 currentAllowance = allowance(owner, spender);
+    if (currentAllowance != type(uint256).max) {
+      require(currentAllowance >= amount, "EToken: insufficient allowance");
+      unchecked {
+        _approve(owner, spender, currentAllowance - amount);
+      }
+    }
+  }
+
   /**
    * @dev Atomically increases the allowance granted to `spender` by the caller.
    *
@@ -256,7 +317,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
    * - `spender` cannot be the zero address.
    */
   function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
-    _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
+    _approve(_msgSender(), spender, allowance(_msgSender(), spender) + addedValue);
     return true;
   }
 
@@ -330,6 +391,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
    */
   function _mint(address account, uint256 amount) internal virtual {
     require(account != address(0), "EToken: mint to the zero address");
+    require(amount > 0, "EToken: amount to mint should be greater than zero");
 
     _beforeTokenTransfer(address(0), account, amount);
     uint256 scaledAmount = _tsScaled.add(amount, tokenInterestRate());
@@ -403,12 +465,12 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     address from,
     address to,
     uint256 amount
-  ) internal virtual {
+  ) internal virtual whenNotPaused {
     require(
       from == address(0) ||
         to == address(0) ||
-        address(policyPool().config().lpWhitelist()) == address(0) ||
-        policyPool().config().lpWhitelist().acceptsTransfer(this, from, to, amount),
+        address(_params.whitelist) == address(0) ||
+        _params.whitelist.acceptsTransfer(this, from, to, amount),
       "Transfer not allowed - Liquidity Provider not whitelisted"
     );
   }
@@ -419,9 +481,10 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     uint256 totalSupply_ = this.totalSupply();
     if (totalSupply_ == 0) _scr.tokenInterestRate = 0;
     else {
-      _scr.tokenInterestRate = uint64(
-        uint256(_scr.interestRate).wadMul(uint256(_scr.scr)).wadDiv(totalSupply_)
-      );
+      _scr.tokenInterestRate = uint256(_scr.interestRate)
+        .wadMul(uint256(_scr.scr))
+        .wadDiv(totalSupply_)
+        .toUint64();
     }
   }
 
@@ -443,6 +506,25 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     else return 0;
   }
 
+  function assetManager() public view override returns (IAssetManager) {
+    return _assetManager;
+  }
+
+  function _setAssetManager(IAssetManager newAM) internal override {
+    _assetManager = newAM;
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function _4toWad(uint16 value) internal pure returns (uint256) {
+    // 4 decimals to Wad (18 decimals)
+    return uint256(value) * FOUR_DECIMAL_TO_WAD;
+  }
+
+  function _wadTo4(uint256 value) internal pure returns (uint16) {
+    // Wad to 4 decimals
+    return (value / FOUR_DECIMAL_TO_WAD).toUint16();
+  }
+
   function scr() public view virtual override returns (uint256) {
     return uint256(_scr.scr);
   }
@@ -456,39 +538,41 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
   }
 
   function liquidityRequirement() public view returns (uint256) {
-    return uint256(_params.liquidityRequirement) * 1e14; // 4 -> 18 decimals
+    return _4toWad(_params.liquidityRequirement);
   }
 
   function maxUtilizationRate() public view returns (uint256) {
-    return uint256(_params.maxUtilizationRate) * 1e14; // 4 -> 18 decimals
+    return _4toWad(_params.maxUtilizationRate);
   }
 
   function minUtilizationRate() public view returns (uint256) {
-    return uint256(_params.minUtilizationRate) * 1e14; // 4 -> 18 decimals
+    return _4toWad(_params.minUtilizationRate);
   }
 
   function utilizationRate() public view returns (uint256) {
     return uint256(_scr.scr).wadDiv(this.totalSupply());
   }
 
-  function lockScr(uint256 scrAmount, uint256 policyInterestRate) external override onlyBorrower {
+  function lockScr(uint256 scrAmount, uint256 policyInterestRate)
+    external
+    override
+    onlyBorrower
+    whenNotPaused
+  {
     require(
       scrAmount <= this.fundsAvailableToLock(),
-      "Not enought funds available to cover the SCR"
+      "Not enough funds available to cover the SCR"
     );
     _tsScaled.updateScale(tokenInterestRate());
     if (_scr.scr == 0) {
-      _scr.scr = uint128(scrAmount);
-      _scr.interestRate = uint64(policyInterestRate);
+      _scr.scr = scrAmount.toUint128();
+      _scr.interestRate = policyInterestRate.toUint64();
     } else {
       uint256 origScr = uint256(_scr.scr);
       uint256 newScr = origScr + scrAmount;
-      _scr.interestRate = uint64(
-        (uint256(_scr.interestRate).wadMul(origScr) + policyInterestRate.wadMul(scrAmount)).wadDiv(
-          newScr
-        )
-      );
-      _scr.scr = uint128(newScr);
+      _scr.interestRate = (uint256(_scr.interestRate).wadMul(origScr) +
+        policyInterestRate.wadMul(scrAmount)).wadDiv(newScr).toUint64();
+      _scr.scr = newScr.toUint128();
     }
     emit SCRLocked(policyInterestRate, scrAmount);
     _updateTokenInterestRate();
@@ -498,7 +582,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     uint256 scrAmount,
     uint256 policyInterestRate,
     int256 adjustment
-  ) external override onlyBorrower {
+  ) external override onlyBorrower whenNotPaused {
     require(scrAmount <= uint256(_scr.scr), "Current SCR less than the amount you want to unlock");
     _tsScaled.updateScale(tokenInterestRate());
 
@@ -508,17 +592,18 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     } else {
       uint256 origScr = uint256(_scr.scr);
       uint256 newScr = origScr - scrAmount;
-      _scr.interestRate = uint64(
-        (uint256(_scr.interestRate).wadMul(origScr) - policyInterestRate.wadMul(scrAmount)).wadDiv(
-          newScr
-        )
-      );
-      _scr.scr = uint128(newScr);
+      _scr.interestRate = (uint256(_scr.interestRate).wadMul(origScr) -
+        policyInterestRate.wadMul(scrAmount)).wadDiv(newScr).toUint64();
+      _scr.scr = newScr.toUint128();
     }
     emit SCRUnlocked(policyInterestRate, scrAmount);
     _discreteChange(adjustment);
   }
 
+  function _assetEarnings(int256 earnings) internal override {
+    _discreteChange(earnings);
+  }
+
   function _discreteChange(int256 amount) internal {
     _tsScaled.discreteChange(amount, tokenInterestRate());
     _updateTokenInterestRate();
@@ -528,12 +613,11 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
     require(
-      address(policyPool().config().lpWhitelist()) == address(0) ||
-        policyPool().config().lpWhitelist().acceptsDeposit(this, provider, amount),
+      address(_params.whitelist) == address(0) ||
+        _params.whitelist.acceptsDeposit(this, provider, amount),
       "Liquidity Provider not whitelisted"
     );
     _mint(provider, amount);
@@ -553,14 +637,15 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
-    uint256 balance = balanceOf(provider);
-    if (balance == 0) return 0;
-    if (amount > balance) amount = balance;
-    uint256 withdrawable = totalWithdrawable();
-    if (amount > withdrawable) amount = withdrawable;
+    /**
+     * Here we don't check for maxUtilizationRate because that limit only affects locking more capital (`lockScr`), but
+     * doesn't affects the right of liquidity providers to withdraw their funds.
+     * The only limit for withdraws is the `totalWithdrawable()` function, that's affected by the relation between the
+     * scr and the totalSupply.
+     */
+    amount = Math.min(amount, Math.min(balanceOf(provider), totalWithdrawable()));
     if (amount == 0) return 0;
     _burn(provider, amount);
     _updateTokenInterestRate();
@@ -569,25 +654,32 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
   }
 
   function addBorrower(address borrower) external override onlyPolicyPool {
+    require(borrower != address(0), "EToken: Borrower cannot be the zero address");
     TimeScaled.ScaledAmount storage loan = _loans[borrower];
     if (loan.scale == 0) {
       loan.init();
-      emit PoolBorrowerAdded(borrower);
+      emit InternalBorrowerAdded(borrower);
     }
   }
 
+  function removeBorrower(address borrower) external override onlyPolicyPool {
+    require(borrower != address(0), "EToken: Borrower cannot be the zero address");
+    uint256 defaultedDebt = getLoan(borrower);
+    delete _loans[borrower];
+    emit InternalBorrowerRemoved(borrower, defaultedDebt);
+  }
+
   function internalLoan(
     uint256 amount,
     address receiver,
     bool fromAvailable
   ) external override onlyBorrower whenNotPaused returns (uint256) {
     uint256 amountAsked = amount;
-    if (fromAvailable && amount > fundsAvailable()) amount = fundsAvailable();
-    if (!fromAvailable && amount > totalSupply()) amount = totalSupply();
-    if (amount > _tsScaled.maxNegativeAdjustment(tokenInterestRate())) {
-      amount = _tsScaled.maxNegativeAdjustment(tokenInterestRate());
-      if (amount == 0) return amountAsked;
-    }
+    amount = Math.min(
+      Math.min(amount, fromAvailable ? fundsAvailable() : totalSupply()),
+      _tsScaled.maxNegativeAdjustment(tokenInterestRate())
+    );
+    if (amount == 0) return amountAsked;
     TimeScaled.ScaledAmount storage loan = _loans[_msgSender()];
     loan.add(amount, internalLoanInterestRate());
     _discreteChange(-int256(amount));
@@ -596,77 +688,91 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     return amountAsked - amount;
   }
 
-  function repayLoan(uint256 amount, address onBehalfOf) external override {
+  function repayLoan(uint256 amount, address onBehalfOf) external override whenNotPaused {
+    require(amount > 0, "EToken: amount should be greater than zero.");
     // Anyone can call this method, since it has to pay
-    currency().safeTransferFrom(_msgSender(), address(this), amount);
     TimeScaled.ScaledAmount storage loan = _loans[onBehalfOf];
     require(loan.scale != 0, "Not a registered borrower");
     loan.sub(amount, internalLoanInterestRate());
     _discreteChange(int256(amount));
     emit InternalLoanRepaid(onBehalfOf, amount);
+    // Interaction at the end for security reasons
+    currency().safeTransferFrom(_msgSender(), address(this), amount);
   }
 
   function getLoan(address borrower) public view virtual override returns (uint256) {
     TimeScaled.ScaledAmount storage loan = _loans[borrower];
-    if (loan.scale == 0) return 0;
     return loan.getScaledAmount(internalLoanInterestRate());
   }
 
   function internalLoanInterestRate() public view returns (uint256) {
-    return uint256(_params.internalLoanInterestRate) * 1e14; // to wad 4 -> 18 digits
+    return _4toWad(_params.internalLoanInterestRate);
   }
 
-  function setInternalLoanInterestRate(uint256 newRate)
+  function setParam(Parameter param, uint256 newValue)
     external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyGlobalOrComponentRole2(LEVEL2_ROLE, LEVEL3_ROLE)
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakWad(internalLoanInterestRate(), newRate, 3e17),
-      "Tweak exceeded: internalLoanInterestRate tweaks only up to 30%"
-    );
-    // This call changes the interest rate without updating the current loans up to this point
-    // So, if interest rate goes from 5% to 6%, this change will be retroactive to the lastUpdate of each
-    // loan. Since it's a permissioned call, I'm ok with this. If a caller wants to reduce the impact, it can
-    // issue 1 wei repayLoan to each active loan, forcing the update of the scales
-    _params.internalLoanInterestRate = uint16(newRate / 1e14);
+    if (param == Parameter.liquidityRequirement) {
+      require(
+        !tweak || _isTweakWad(liquidityRequirement(), newValue, 1e17),
+        "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
+      );
+      _params.liquidityRequirement = _wadTo4(newValue);
+    } else if (param == Parameter.minUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(minUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: minUtilizationRate tweaks only up to 30%"
+      );
+      _params.minUtilizationRate = _wadTo4(newValue);
+    } else if (param == Parameter.maxUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(maxUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
+      );
+      _params.maxUtilizationRate = _wadTo4(newValue);
+    } else if (param == Parameter.internalLoanInterestRate) {
+      require(
+        !tweak || _isTweakWad(internalLoanInterestRate(), newValue, 3e17),
+        "Tweak exceeded: internalLoanInterestRate tweaks only up to 30%"
+      );
+      // This call changes the interest rate without updating the current loans up to this point
+      // So, if interest rate goes from 5% to 6%, this change will be retroactive to the lastUpdate of each
+      // loan. Since it's a permissioned call, I'm ok with this. If a caller wants to reduce the impact, it can
+      // issue 1 wei repayLoan to each active loan, forcing the update of the scales
+      _params.internalLoanInterestRate = _wadTo4(newValue);
+    }
     _parameterChanged(
-      IPolicyPoolConfig.GovernanceActions.setInternalLoanInterestRate,
-      newRate,
+      IAccessManager.GovernanceActions(
+        uint256(IAccessManager.GovernanceActions.setLiquidityRequirement) + uint256(param)
+      ),
+      newValue,
       tweak
     );
   }
 
-  function setLiquidityRequirement(uint256 newRate)
+  function setWhitelist(ILPWhitelist lpWhitelist_)
     external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyGlobalOrComponentRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
   {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
-      !tweak || _isTweakWad(liquidityRequirement(), newRate, 1e17),
-      "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
+      address(lpWhitelist_) == address(0) ||
+        IPolicyPoolComponent(address(lpWhitelist_)).policyPool() == _policyPool,
+      "Component not linked to this PolicyPool"
     );
-    _params.liquidityRequirement = uint16(newRate / 1e14);
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityRequirement, newRate, tweak);
+    _params.whitelist = lpWhitelist_;
+    _componentChanged(IAccessManager.GovernanceActions.setLPWhitelist, address(lpWhitelist_));
   }
 
-  function setMaxUtilizationRate(uint256 newRate) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakWad(maxUtilizationRate(), newRate, 3e17),
-      "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
-    );
-    _params.maxUtilizationRate = uint16(newRate / 1e14);
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxUtilizationRate, newRate, tweak);
+  function whitelist() external view returns (ILPWhitelist) {
+    return _params.whitelist;
   }
 
-  function setMinUtilizationRate(uint256 newRate) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakWad(minUtilizationRate(), newRate, 3e17),
-      "Tweak exceeded: minUtilizationRate tweaks only up to 30%"
-    );
-    _params.minUtilizationRate = uint16(newRate / 1e14);
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMinUtilizationRate, newRate, tweak);
-  }
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[41] private __gap;
 }

package/contracts/LPManualWhitelist.sol

@@ -32,10 +32,19 @@ contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
 
   function whitelistAddress(address provider, bool whitelisted)
     external
-    onlyPoolRole(LP_WHITELIST_ROLE)
+    onlyComponentRole(LP_WHITELIST_ROLE)
   {
-    _whitelisted[provider] = whitelisted;
-    emit LPWhitelisted(provider, whitelisted);
+    if (_whitelisted[provider] != whitelisted) {
+      _whitelisted[provider] = whitelisted;
+      emit LPWhitelisted(provider, whitelisted);
+    }
+  }
+
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   */
+  function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+    return super.supportsInterface(interfaceId) || interfaceId == type(ILPWhitelist).interfaceId;
   }
 
   function acceptsDeposit(
@@ -54,4 +63,11 @@ contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
   ) external view override returns (bool) {
     return _whitelisted[providerTo];
   }
+
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[49] private __gap;
 }