@ensuro/core 2.0.0-beta1 → 2.0.0-beta10

package/contracts/EToken.sol

@@ -3,11 +3,16 @@ pragma solidity ^0.8.0;
 
 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 +29,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
   using WadRayMath for uint256;
   using TimeScaled for TimeScaled.ScaledAmount;
   using SafeERC20 for IERC20Metadata;
-
-  uint256 internal constant SECONDS_PER_YEAR = 365 days;
+  using SafeCast for uint256;
 
   // Attributes taken from ERC20
   mapping(address => uint256) private _balances;
@@ -52,13 +56,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");
@@ -102,10 +110,11 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
       tokenInterestRate: 0
     }); */
     _params = PackedParams({
-      maxUtilizationRate: uint16(maxUtilizationRate_ / 1e14),
+      maxUtilizationRate: _wadTo4(maxUtilizationRate_),
       liquidityRequirement: 1e4,
       minUtilizationRate: 0,
-      internalLoanInterestRate: uint16(internalLoanInterestRate_ / 1e14)
+      internalLoanInterestRate: _wadTo4(internalLoanInterestRate_),
+      whitelist: ILPWhitelist(address(0))
     });
 
     _validateParameters();
@@ -403,12 +412,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 +428,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 +453,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) * 1e14;
+  }
+
+  function _wadTo4(uint256 value) internal pure returns (uint16) {
+    // Wad to 4 decimals
+    return (value / 1e14).toUint16();
+  }
+
   function scr() public view virtual override returns (uint256) {
     return uint256(_scr.scr);
   }
@@ -456,39 +485,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"
     );
     _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();
@@ -508,17 +539,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 +560,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 +584,9 @@ 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;
+    amount = Math.min(amount, Math.min(balanceOf(provider), totalWithdrawable()));
     if (amount == 0) return 0;
     _burn(provider, amount);
     _updateTokenInterestRate();
@@ -572,22 +598,27 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     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 {
+    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));
@@ -608,65 +639,70 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
 
   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%"
-    );
-    _params.liquidityRequirement = uint16(newRate / 1e14);
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityRequirement, newRate, tweak);
-  }
-
-  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%"
+      address(lpWhitelist_) == address(0) ||
+        IPolicyPoolComponent(address(lpWhitelist_)).policyPool() == _policyPool,
+      "Component not linked to this PolicyPool"
     );
-    _params.maxUtilizationRate = uint16(newRate / 1e14);
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxUtilizationRate, newRate, tweak);
+    _params.whitelist = lpWhitelist_;
+    _componentChanged(IAccessManager.GovernanceActions.setLPWhitelist, address(lpWhitelist_));
   }
 
-  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);
+  function whitelist() external view returns (ILPWhitelist) {
+    return _params.whitelist;
   }
 }

package/contracts/LPManualWhitelist.sol

@@ -32,7 +32,7 @@ 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);

package/contracts/LiquidityThresholdAssetManager.sol

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IPolicyPoolComponent} from "./interfaces/IPolicyPoolComponent.sol";
+import {IAssetManager} from "./interfaces/IAssetManager.sol";
+import {IAccessManager} from "./interfaces/IAccessManager.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+
+/**
+ * @title Base class for asset management strategies that use thresholds for cash and investment balance
+ * @dev Base class for asset management strategies that use thresholds for cash and investment balance.
+ *      The specific asset management strategy needs to be implemented by child contracts.
+ *      Settings liquidityMin, liquidityMiddle, liquidityMax are the thresholds used to define how much liquidity
+ *      to keep in the PolicyPool and when to invest/deinvest. Every invest/deinvest operation tries to leave the
+ *      cash at liquidityMiddle.
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+abstract contract LiquidityThresholdAssetManager is IAssetManager {
+  using SafeCast for uint256;
+
+  IERC20Metadata internal immutable _asset;
+  event GovernanceAction(IAccessManager.GovernanceActions indexed action, uint256 value);
+
+  struct DiamondStorage {
+    uint32 liquidityMin; // stored with 0 decimals
+    uint32 liquidityMiddle; // stored with 0 decimals
+    uint32 liquidityMax; // stored with 0 decimals
+    uint128 lastInvestmentValue;
+  }
+
+  modifier validateParamsAfterChange() {
+    _;
+    _validateParameters();
+  }
+
+  constructor(IERC20Metadata asset_) {
+    _asset = asset_;
+  }
+
+  function diamondStorage() internal pure returns (DiamondStorage storage ds) {
+    // Inspired from https://eips.ethereum.org/EIPS/eip-2535#facets-state-variables-and-diamond-storage
+    // Set the position of our struct in contract storage
+    bytes32 storagePosition = keccak256("co.ensuro.LiquidityThresholdAssetManager");
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      ds.slot := storagePosition
+    }
+  }
+
+  function _validateParameters() internal view {
+    DiamondStorage storage ds = diamondStorage();
+
+    require(
+      ds.liquidityMin <= ds.liquidityMiddle && ds.liquidityMiddle <= ds.liquidityMax,
+      "Validation: Liquidity limits are invalid"
+    );
+  }
+
+  function connect() public virtual override {
+    require(
+      IPolicyPoolComponent(address(this)).policyPool().currency() == _asset,
+      "Asset mismatch"
+    );
+  }
+
+  function recordEarnings() external virtual override returns (int256) {
+    uint256 investmentValue = getInvestmentValue();
+    DiamondStorage storage ds = diamondStorage();
+    int256 earnings = int256(investmentValue) - int256(uint256(ds.lastInvestmentValue));
+    ds.lastInvestmentValue = investmentValue.toUint128();
+    emit EarningsRecorded(earnings);
+    return earnings;
+  }
+
+  /**
+   * @dev Returns the current value of the investment portfolio
+   */
+  function getInvestmentValue() public view virtual returns (uint256);
+
+  /**
+   * @dev Rebalances cash between PolicyPool wallet and
+   */
+  function rebalance() external virtual override {
+    uint256 cash = _asset.balanceOf(address(this));
+    if (cash > liquidityMax()) {
+      _invest(cash - liquidityMiddle());
+    } else if (cash < liquidityMin()) {
+      uint256 deinvestAmount = Math.min(getInvestmentValue(), liquidityMiddle() - cash);
+      if (deinvestAmount > 0) {
+        _deinvest(deinvestAmount);
+      }
+    }
+  }
+
+  /**
+   * @dev This is called from PolicyPool when doesn't have enought money for payment.
+   *      After the call, there should be enought money in PolicyPool.currency().balanceOf(this) to
+   *      do the payment
+   * @param paymentAmount The amount of the payment
+   */
+  function refillWallet(uint256 paymentAmount) external override returns (uint256 deinvest) {
+    uint256 cash = _asset.balanceOf(address(this));
+    require(cash < paymentAmount, "No need to refill the wallet for this payment");
+    uint256 investmentValue = getInvestmentValue();
+    // try to leave the pool balance at liquidity_middle after the payment
+    deinvest = paymentAmount + liquidityMiddle() - cash;
+    if (deinvest > investmentValue) deinvest = investmentValue;
+    _deinvest(deinvest);
+    return deinvest;
+  }
+
+  function _invest(uint256 amount) internal virtual {
+    DiamondStorage storage ds = diamondStorage();
+    ds.lastInvestmentValue += amount.toUint128();
+    emit MoneyInvested(amount);
+    // must be reimplemented do the actual cash movement
+  }
+
+  function _deinvest(uint256 amount) internal virtual {
+    DiamondStorage storage ds = diamondStorage();
+    ds.lastInvestmentValue -= Math.min(uint256(ds.lastInvestmentValue), amount).toUint128();
+    emit MoneyDeinvested(amount);
+    // must be reimplemented do the actual cash movement
+  }
+
+  function liquidityMin() public view returns (uint256) {
+    return diamondStorage().liquidityMin * 10**_asset.decimals();
+  }
+
+  function liquidityMiddle() public view returns (uint256) {
+    return diamondStorage().liquidityMiddle * 10**_asset.decimals();
+  }
+
+  function liquidityMax() public view returns (uint256) {
+    return diamondStorage().liquidityMax * 10**_asset.decimals();
+  }
+
+  function setLiquidityThresholds(
+    uint256 min,
+    uint256 middle,
+    uint256 max
+  ) external validateParamsAfterChange {
+    DiamondStorage storage ds = diamondStorage();
+    if (min != type(uint256).max) {
+      ds.liquidityMin = (min / 10**_asset.decimals()).toUint32();
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMin, min);
+    }
+    if (middle != type(uint256).max) {
+      ds.liquidityMiddle = (middle / 10**_asset.decimals()).toUint32();
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMiddle, middle);
+    }
+    if (max != type(uint256).max) {
+      ds.liquidityMax = (max / 10**_asset.decimals()).toUint32();
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMax, max);
+    }
+  }
+}

package/contracts/Policy.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
-import {WadRayMath} from "./WadRayMath.sol";
+import {WadRayMath} from "./dependencies/WadRayMath.sol";
 import {IRiskModule} from "./interfaces/IRiskModule.sol";
 
 /**