@ensuro/core 2.0.0-beta6 → 2.0.0-beta8

package/contracts/AccessManager.sol

@@ -38,24 +38,47 @@ contract AccessManager is Initializable, AccessControlUpgradeable, UUPSUpgradeab
   // solhint-disable-next-line no-empty-blocks
   function _authorizeUpgrade(address) internal override onlyRole2(GUARDIAN_ROLE, LEVEL1_ROLE) {}
 
-  function getComponentRole(address component, bytes32 role) public pure returns (bytes32) {
+  function getComponentRole(address component, bytes32 role)
+    public
+    pure
+    override
+    returns (bytes32)
+  {
     return bytes32(bytes20(component)) ^ role;
   }
 
+  function hasComponentRole(
+    address component,
+    bytes32 role,
+    address account,
+    bool alsoGlobal
+  ) public view override returns (bool) {
+    return
+      (alsoGlobal && hasRole(role, account)) || hasRole(getComponentRole(component, role), account);
+  }
+
   function checkComponentRole(
     address component,
     bytes32 role,
-    address account
+    address account,
+    bool alsoGlobal
   ) external view override {
-    _checkRole(getComponentRole(component, role), account);
+    if (!alsoGlobal || !hasRole(role, account)) {
+      _checkRole(getComponentRole(component, role), account);
+    }
   }
 
-  function grantComponentRole(
+  function checkComponentRole2(
     address component,
-    bytes32 role,
-    address account
-  ) external onlyRole(getRoleAdmin(getComponentRole(component, role))) {
-    _grantRole(getComponentRole(component, role), account);
+    bytes32 role1,
+    bytes32 role2,
+    address account,
+    bool alsoGlobal
+  ) external view override {
+    if (alsoGlobal && hasRole(role1, account)) return;
+    if (hasRole(getComponentRole(component, role1), account)) return;
+    if (alsoGlobal && hasRole(role2, account)) return;
+    _checkRole(getComponentRole(component, role2), account);
   }
 
   function checkRole(bytes32 role, address account) external view override {
@@ -69,4 +92,12 @@ contract AccessManager is Initializable, AccessControlUpgradeable, UUPSUpgradeab
   ) external view override {
     if (!hasRole(role1, account)) _checkRole(role2, account);
   }
+
+  function grantComponentRole(
+    address component,
+    bytes32 role,
+    address account
+  ) external onlyRole(getRoleAdmin(getComponentRole(component, role))) {
+    _grantRole(getComponentRole(component, role), account);
+  }
 }

package/contracts/ERC4626AssetManager.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {LiquidityThresholdAssetManager} from "./LiquidityThresholdAssetManager.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+
+/**
+ * @title Asset Manager that deploys the funds into an ERC4626 vault
+ * @dev Using liquidity thresholds defined in {LiquidityThresholdAssetManager}, deploys the funds into an ERC4626 vault.
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract ERC4626AssetManager is LiquidityThresholdAssetManager {
+  IERC4626 internal immutable _vault;
+
+  constructor(IERC20Metadata asset_, IERC4626 vault_) LiquidityThresholdAssetManager(asset_) {
+    _vault = vault_;
+  }
+
+  function connect() public override {
+    super.connect();
+    _asset.approve(address(_vault), type(uint256).max); // infinite approval to the vault
+  }
+
+  function _invest(uint256 amount) internal override {
+    super._invest(amount);
+    _vault.deposit(amount, address(this));
+  }
+
+  function _deinvest(uint256 amount) internal override {
+    super._deinvest(amount);
+    _vault.withdraw(amount, address(this), address(this));
+  }
+
+  function deinvestAll() external override returns (int256 earnings) {
+    DiamondStorage storage ds = diamondStorage();
+    uint256 assets = _vault.redeem(_vault.balanceOf(address(this)), address(this), address(this));
+    earnings = int256(assets) - int256(uint256(ds.lastInvestmentValue));
+    ds.lastInvestmentValue = uint128(assets);
+    emit MoneyDeinvested(assets);
+    emit EarningsRecorded(earnings);
+    return earnings;
+  }
+
+  function getInvestmentValue() public view override returns (uint256) {
+    return _vault.convertToAssets(_vault.balanceOf(address(this)));
+  }
+}

package/contracts/EToken.sol

@@ -9,6 +9,7 @@ import {IEToken} from "./interfaces/IEToken.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 "./WadRayMath.sol";
 import {TimeScaled} from "./TimeScaled.sol";
 
@@ -59,9 +60,12 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
 
   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");
@@ -407,7 +411,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     address from,
     address to,
     uint256 amount
-  ) internal virtual {
+  ) internal virtual whenNotPaused {
     require(
       from == address(0) ||
         to == address(0) ||
@@ -447,6 +451,14 @@ 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;
+  }
+
   function scr() public view virtual override returns (uint256) {
     return uint256(_scr.scr);
   }
@@ -475,7 +487,12 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     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"
@@ -523,6 +540,10 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     _discreteChange(adjustment);
   }
 
+  function _assetEarnings(int256 earnings) internal override {
+    _discreteChange(earnings);
+  }
+
   function _discreteChange(int256 amount) internal {
     _tsScaled.discreteChange(amount, tokenInterestRate());
     _updateTokenInterestRate();
@@ -532,7 +553,6 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
     require(
@@ -557,7 +577,6 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
     uint256 balance = balanceOf(provider);
@@ -576,10 +595,16 @@ 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,
@@ -620,59 +645,54 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
     return uint256(_params.internalLoanInterestRate) * 1e14; // to wad 4 -> 18 digits
   }
 
-  function setInternalLoanInterestRate(uint256 newRate)
-    external
-    onlyPoolRole2(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);
-    _parameterChanged(IAccessManager.GovernanceActions.setInternalLoanInterestRate, newRate, tweak);
-  }
-
-  function setLiquidityRequirement(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(liquidityRequirement(), newRate, 1e17),
-      "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
-    );
-    _params.liquidityRequirement = uint16(newRate / 1e14);
-    _parameterChanged(IAccessManager.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%"
-    );
-    _params.maxUtilizationRate = uint16(newRate / 1e14);
-    _parameterChanged(IAccessManager.GovernanceActions.setMaxUtilizationRate, newRate, tweak);
-  }
-
-  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%"
+    if (param == Parameter.liquidityRequirement) {
+      require(
+        !tweak || _isTweakWad(liquidityRequirement(), newValue, 1e17),
+        "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
+      );
+      _params.liquidityRequirement = uint16(newValue / 1e14);
+    } else if (param == Parameter.minUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(minUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: minUtilizationRate tweaks only up to 30%"
+      );
+      _params.minUtilizationRate = uint16(newValue / 1e14);
+    } else if (param == Parameter.maxUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(maxUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
+      );
+      _params.maxUtilizationRate = uint16(newValue / 1e14);
+    } 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 = uint16(newValue / 1e14);
+    } else {
+      revert("Invalid param!");
+    }
+    _parameterChanged(
+      IAccessManager.GovernanceActions(
+        uint256(IAccessManager.GovernanceActions.setLiquidityRequirement) + uint256(param)
+      ),
+      newValue,
+      tweak
     );
-    _params.minUtilizationRate = uint16(newRate / 1e14);
-    _parameterChanged(IAccessManager.GovernanceActions.setMinUtilizationRate, newRate, tweak);
   }
 
   function setWhitelist(ILPWhitelist lpWhitelist_)
     external
-    onlyPoolRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
+    onlyGlobalOrComponentRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
   {
     require(
       address(lpWhitelist_) == address(0) ||
@@ -680,7 +700,7 @@ contract EToken is Reserve, IERC20Metadata, IEToken {
       "Component not linked to this PolicyPool"
     );
     _params.whitelist = lpWhitelist_;
-    emit ComponentChanged(IAccessManager.GovernanceActions.setLPWhitelist, address(lpWhitelist_));
+    _componentChanged(IAccessManager.GovernanceActions.setLPWhitelist, address(lpWhitelist_));
   }
 
   function whitelist() external view returns (ILPWhitelist) {

package/contracts/LiquidityThresholdAssetManager.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {WadRayMath} from "./WadRayMath.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 WadRayMath 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 = uint128(investmentValue);
+    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 {
+    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
+    uint256 deinvest = paymentAmount + liquidityMiddle() - cash;
+    if (deinvest > investmentValue) deinvest = investmentValue;
+    _deinvest(deinvest);
+  }
+
+  function _invest(uint256 amount) internal virtual {
+    DiamondStorage storage ds = diamondStorage();
+    ds.lastInvestmentValue += uint128(amount);
+    emit MoneyInvested(amount);
+    // must be reimplemented do the actual cash movement
+  }
+
+  function _deinvest(uint256 amount) internal virtual {
+    DiamondStorage storage ds = diamondStorage();
+    ds.lastInvestmentValue -= uint128(Math.min(uint256(ds.lastInvestmentValue), amount));
+    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 = uint32(min / 10**_asset.decimals());
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMin, min);
+    }
+    if (middle != type(uint256).max) {
+      ds.liquidityMiddle = uint32(middle / 10**_asset.decimals());
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMiddle, middle);
+    }
+    if (max != type(uint256).max) {
+      ds.liquidityMax = uint32(max / 10**_asset.decimals());
+      emit GovernanceAction(IAccessManager.GovernanceActions.setLiquidityMax, max);
+    }
+  }
+}