@ensuro/core 1.2.7 → 2.0.0-beta10

package/contracts/LPManualWhitelist.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
 import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
-import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
-import {IEToken} from "../interfaces/IEToken.sol";
+import {ILPWhitelist} from "./interfaces/ILPWhitelist.sol";
+import {IEToken} from "./interfaces/IEToken.sol";
 
 /**
  * @title Manual Whitelisting contract
@@ -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,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
-import {WadRayMath} from "./WadRayMath.sol";
-import {IRiskModule} from "../interfaces/IRiskModule.sol";
+import {WadRayMath} from "./dependencies/WadRayMath.sol";
+import {IRiskModule} from "./interfaces/IRiskModule.sol";
 
 /**
  * @title Policy library
@@ -13,33 +13,30 @@ import {IRiskModule} from "../interfaces/IRiskModule.sol";
 library Policy {
   using WadRayMath for uint256;
 
-  uint256 internal constant SECONDS_IN_YEAR = 31536000e18; /* 365 * 24 * 3600 * 10e18 */
-  uint256 internal constant SECONDS_IN_YEAR_RAY = 31536000e27; /* 365 * 24 * 3600 * 10e27 */
+  uint256 internal constant SECONDS_PER_YEAR = 365 days;
 
   // Active Policies
   struct PolicyData {
     uint256 id;
     uint256 payout;
     uint256 premium;
-    uint256 scr;
-    uint256 lossProb; // original loss probability (in ray)
+    uint256 jrScr;
+    uint256 srScr;
+    uint256 lossProb; // original loss probability (in wad)
     uint256 purePremium; // share of the premium that covers expected losses
     // equal to payout * lossProb * riskModule.moc
-    uint256 premiumForEnsuro; // share of the premium that goes for Ensuro (if policy won)
-    uint256 premiumForRm; // share of the premium that goes for the RM (if policy won)
-    uint256 premiumForLps; // share of the premium that goes to the liquidity providers (won or not)
+    uint256 ensuroCommission; // share of the premium that goes for Ensuro
+    uint256 partnerCommission; // share of the premium that goes for the RM
+    uint256 jrCoc; // share of the premium that goes to junior liquidity providers (won or not)
+    uint256 srCoc; // share of the premium that goes to senior liquidity providers (won or not)
     IRiskModule riskModule;
     uint40 start;
     uint40 expiration;
   }
 
-  /// #if_succeeds {:msg "premium preserved"} premium == (newPolicy.premium);
-  /// #if_succeeds
-  ///    {:msg "premium distributed"}
-  ///    premium == (newPolicy.purePremium + newPolicy.premiumForLps +
-  ///                newPolicy.premiumForRm + newPolicy.premiumForEnsuro);
   function initialize(
     IRiskModule riskModule,
+    IRiskModule.Params memory rmParams,
     uint256 premium,
     uint256 payout,
     uint256 lossProb,
@@ -47,55 +44,62 @@ library Policy {
   ) internal view returns (PolicyData memory newPolicy) {
     require(premium <= payout, "Premium cannot be more than payout");
     PolicyData memory policy;
+
     policy.riskModule = riskModule;
     policy.premium = premium;
     policy.payout = payout;
     policy.lossProb = lossProb;
-    policy.purePremium = payout.wadToRay().rayMul(lossProb.rayMul(riskModule.moc())).rayToWad();
-    policy.scr = payout.wadMul(riskModule.scrPercentage().rayToWad()) - policy.purePremium;
-    require(policy.scr != 0, "SCR can't be zero");
     policy.start = uint40(block.timestamp);
     policy.expiration = expiration;
-    policy.premiumForLps = policy.scr.wadMul(
-      (
-        (riskModule.scrInterestRate() * (policy.expiration - policy.start)).rayDiv(
-          SECONDS_IN_YEAR_RAY
-        )
-      ).rayToWad()
+    policy.purePremium = payout.wadMul(lossProb.wadMul(rmParams.moc));
+    // Calculate Junior and Senior SCR
+    policy.jrScr = payout.wadMul(rmParams.jrCollRatio);
+    if (policy.jrScr > policy.purePremium) {
+      policy.jrScr -= policy.purePremium;
+    } else {
+      policy.jrScr = 0;
+    }
+    policy.srScr = payout.wadMul(rmParams.collRatio);
+    if (policy.srScr > (policy.purePremium + policy.jrScr)) {
+      policy.srScr -= policy.purePremium + policy.jrScr;
+    } else {
+      policy.srScr = 0;
+    }
+    // Calculate CoCs
+    policy.jrCoc = policy.jrScr.wadMul(
+      (rmParams.jrRoc * (policy.expiration - policy.start)) / SECONDS_PER_YEAR
     );
-    policy.premiumForEnsuro = (policy.purePremium + policy.premiumForLps).wadMul(
-      riskModule.ensuroFee().rayToWad()
+    policy.srCoc = policy.srScr.wadMul(
+      (rmParams.srRoc * (policy.expiration - policy.start)) / SECONDS_PER_YEAR
     );
+    uint256 coc = policy.jrCoc + policy.srCoc;
+    policy.ensuroCommission =
+      policy.purePremium.wadMul(rmParams.ensuroPpFee) +
+      coc.wadMul(rmParams.ensuroCocFee);
     require(
-      policy.purePremium + policy.premiumForEnsuro + policy.premiumForLps <= premium,
+      (policy.purePremium + policy.ensuroCommission + coc) <= premium,
       "Premium less than minimum"
     );
-    policy.premiumForRm =
-      premium -
-      policy.purePremium -
-      policy.premiumForLps -
-      policy.premiumForEnsuro;
+    policy.partnerCommission = premium - policy.purePremium - coc - policy.ensuroCommission;
     return policy;
   }
 
-  function interestRate(PolicyData memory policy) internal pure returns (uint256) {
+  function jrInterestRate(PolicyData memory policy) internal pure returns (uint256) {
     return
-      policy
-        .premiumForLps
-        .wadMul(SECONDS_IN_YEAR)
-        .wadDiv((policy.expiration - policy.start) * policy.scr)
-        .wadToRay();
+      ((policy.jrCoc * SECONDS_PER_YEAR) / (policy.expiration - policy.start)).wadDiv(policy.jrScr);
+  }
+
+  function jrAccruedInterest(PolicyData memory policy) internal view returns (uint256) {
+    return (policy.jrCoc * (block.timestamp - policy.start)) / (policy.expiration - policy.start);
   }
 
-  function accruedInterest(PolicyData memory policy) internal view returns (uint256) {
-    uint256 secs = block.timestamp - policy.start;
+  function srInterestRate(PolicyData memory policy) internal pure returns (uint256) {
     return
-      policy
-        .scr
-        .wadToRay()
-        .rayMul(secs * interestRate(policy))
-        .rayDiv(SECONDS_IN_YEAR_RAY)
-        .rayToWad();
+      ((policy.srCoc * SECONDS_PER_YEAR) / (policy.expiration - policy.start)).wadDiv(policy.srScr);
+  }
+
+  function srAccruedInterest(PolicyData memory policy) internal view returns (uint256) {
+    return (policy.srCoc * (block.timestamp - policy.start)) / (policy.expiration - policy.start);
   }
 
   function hash(PolicyData memory policy) internal pure returns (bytes32) {