@ensuro/core 1.2.7 → 2.0.0-beta3

package/contracts/FlightDelayRiskModule.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
 import {Policy} from "./Policy.sol";
 import {RiskModule} from "./RiskModule.sol";
 import {Chainlink} from "@chainlink/contracts/src/v0.8/Chainlink.sol";
@@ -44,39 +45,40 @@ contract FlightDelayRiskModule is RiskModule, ChainlinkClientUpgradeable {
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_) RiskModule(policyPool_) {}
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
+    RiskModule(policyPool_, premiumsAccount_)
+  {} // solhint-disable-line no-empty-blocks
 
   /**
    * @dev Initializes the RiskModule
    * @param name_ Name of the Risk Module
-   * @param scrPercentage_ Solvency Capital Requirement percentage, to calculate
-                           capital requirement as % of (payout - premium)  (in ray)
-   * @param ensuroFee_ % of premium that will go for Ensuro treasury (in ray)
-   * @param scrInterestRate_ cost of capital (in ray)
-   * @param maxScrPerPolicy_ Max SCR to be allocated to this module (in wad)
-   * @param scrLimit_ Max SCR to be allocated to this module (in wad)
+   * @param collRatio_ Collateralization ratio to compute solvency requirement as % of payout (in ray)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in ray)
+   * @param srRoc_ return on capital paid to Senior LPs (annualized percentage - in ray)
+   * @param maxPayoutPerPolicy_ Maximum payout per policy (in wad)
+   * @param exposureLimit_ Max exposure (sum of payouts) to be allocated to this module (in wad)
    * @param wallet_ Address of the RiskModule provider
    * @param linkToken_ Address of ChainLink LINK token
    * @param oracleParams_ Parameters of the Oracle
    */
   function initialize(
     string memory name_,
-    uint256 scrPercentage_,
-    uint256 ensuroFee_,
-    uint256 scrInterestRate_,
-    uint256 maxScrPerPolicy_,
-    uint256 scrLimit_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
     address wallet_,
     address linkToken_,
     OracleParams memory oracleParams_
   ) public initializer {
     __RiskModule_init(
       name_,
-      scrPercentage_,
-      ensuroFee_,
-      scrInterestRate_,
-      maxScrPerPolicy_,
-      scrLimit_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
       wallet_
     );
     __ChainlinkClient_init();
@@ -92,7 +94,10 @@ contract FlightDelayRiskModule is RiskModule, ChainlinkClientUpgradeable {
     _oracleParams = oracleParams_;
   }
 
-  function setOracleParams(OracleParams memory newParams) external onlyRole(ORACLE_ADMIN_ROLE) {
+  function setOracleParams(OracleParams memory newParams)
+    external
+    onlyComponentRole(ORACLE_ADMIN_ROLE)
+  {
     _oracleParams = newParams;
   }
 
@@ -121,7 +126,7 @@ contract FlightDelayRiskModule is RiskModule, ChainlinkClientUpgradeable {
     uint256 lossProb,
     address customer,
     uint96 internalId
-  ) external onlyRole(PRICER_ROLE) returns (uint256) {
+  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
     require(expectedArrival > block.timestamp, "expectedArrival can't be in the past");
     require(departure != 0 && expectedArrival > departure, "expectedArrival <= departure!");
     uint40 expiration = expectedArrival +
@@ -176,7 +181,11 @@ contract FlightDelayRiskModule is RiskModule, ChainlinkClientUpgradeable {
    * @dev Forces the resolution of the policy (without waiting Chainlink scheduled on creation)
    * @param policyId The id of the policy previously created (in newPolicy)
    */
-  function resolvePolicy(uint256 policyId) external onlyRole(PRICER_ROLE) returns (uint256) {
+  function resolvePolicy(uint256 policyId)
+    external
+    onlyComponentRole(PRICER_ROLE)
+    returns (uint256)
+  {
     PolicyData storage policy = _policies[policyId];
     require(policy.expectedArrival != 0, "Policy not found!");
     _chainlinkRequest(policyId, policy, 0);

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/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 {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) {

package/contracts/PolicyNFT.sol

@@ -4,9 +4,9 @@ pragma solidity ^0.8.2;
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
 import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-import {IPolicyNFT} from "../interfaces/IPolicyNFT.sol";
+import {IPolicyNFT} from "./interfaces/IPolicyNFT.sol";
 
 /**
  * @title PolicyNFT - NFT that keeps track of issued policies and its owners