@ensuro/core 2.0.0-beta1 → 2.0.0-beta10

package/contracts/interfaces/IRiskModule.sol

@@ -9,6 +9,9 @@ import {IPremiumsAccount} from "./IPremiumsAccount.sol";
  * @author Ensuro
  */
 interface IRiskModule {
+  /**
+   * @dev Enum with the different parameters of the risk module, used in {RiskModule-setParam}.
+   */
   enum Parameter {
     moc,
     jrCollRatio,
@@ -22,28 +25,85 @@ interface IRiskModule {
     maxDuration
   }
 
+  /**
+   * Struct of the parameters of the risk module that are used to calculate the different Policy fields (see
+   * {Policy-PolicyData}.
+   */
   struct Params {
+    /**
+     * @dev MoC (Margin of Conservativism) is a factor that multiplies the lossProb to increase or decrease the pure
+     * premium.
+     */
     uint256 moc;
+    /**
+     * @dev Junior Collateralization Ratio is the percentage of policy exposure (payout) that will be covered with the
+     * purePremium and the Junior EToken
+     */
     uint256 jrCollRatio;
+    /**
+     * @dev Collateralization Ratio is the percentage of policy exposure (payout) that will be covered by the
+     * purePremium and the Junior and Senior EToken. Usually is calculated as the relation between VAR99.5% and VAR100
+     * (full collateralization).
+     */
     uint256 collRatio;
+    /**
+     * @dev Ensuro PurePremium Fee is the percentage that will be multiplied by the pure premium to obtain the part of
+     * the Ensuro Fee that's proportional to the pure premium.
+     */
     uint256 ensuroPpFee;
+    /**
+     * @dev Ensuro Cost of Capital Fee is the percentage that will be multiplied by the cost of capital (CoC) to
+     * obtain the part of the Ensuro Fee that's proportional to the CoC.
+     */
     uint256 ensuroCocFee;
+    /**
+     * @dev Junior Return on Capital is the annualized interest rate that's charged for the capital locked in the Junior
+     * EToken.
+     */
     uint256 jrRoc;
+    /**
+     * @dev Senior Return on Capital is the annualized interest rate that's charged for the capital locked in the Senior
+     * EToken.
+     */
     uint256 srRoc;
   }
 
+  /**
+   * @dev A readable name of this risk module. Never changes.
+   */
   function name() external view returns (string memory);
 
+  /**
+   * @dev Returns different parameters of the risk module (see {Params})
+   */
   function params() external view returns (Params memory);
 
-  function maxPayoutPerPolicy() external view returns (uint256);
-
-  function exposureLimit() external view returns (uint256);
-
+  /**
+   * @dev Returns the maximum duration (in hours) of the policies of this risk module.
+   *      The `expiration` of the policies has to be `<= (block.timestamp + 3600 * maxDuration())`
+   */
   function maxDuration() external view returns (uint256);
 
+  /**
+   * @dev Returns the maximum payout accepted for new policies.
+   */
+  function maxPayoutPerPolicy() external view returns (uint256);
+
+  /**
+   * @dev Returns sum of the (maximum) payout of the active policies of this risk module, i.e. the maximum possible
+   * amount of money that's exposed for this risk module.
+   */
   function activeExposure() external view returns (uint256);
 
+  /**
+   * @dev Returns maximum exposure (sum of the (maximum) payout of the active policies) of this risk module.
+   * `activeExposure() <= exposureLimit()` always
+   */
+  function exposureLimit() external view returns (uint256);
+
+  /**
+   * @dev Returns the address of the partner that receives the partnerCommission
+   */
   function wallet() external view returns (address);
 
   /**
@@ -56,5 +116,8 @@ interface IRiskModule {
    */
   function releaseExposure(uint256 payout) external;
 
+  /**
+   * @dev Returns the {PremiumsAccount} where the premiums of this risk module are collected. Never changes.
+   */
   function premiumsAccount() external view returns (IPremiumsAccount);
 }

package/contracts/mocks/FixedRateVault.sol

@@ -0,0 +1,85 @@
+//SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC4626} from "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IMintableERC20} from "./IMintableERC20.sol";
+import {TimeScaled} from "../TimeScaled.sol";
+
+contract FixedRateVault is ERC4626 {
+  using TimeScaled for TimeScaled.ScaledAmount;
+
+  uint256 internal _interestRate;
+  TimeScaled.ScaledAmount internal _totalAssets;
+  bool internal _broken;
+
+  constructor(
+    string memory name_,
+    string memory symbol_,
+    IERC20Metadata asset_,
+    uint256 interestRate_
+  ) ERC20(name_, symbol_) ERC4626(asset_) {
+    _interestRate = interestRate_;
+    _totalAssets.init();
+  }
+
+  /** @dev See {IERC4262-totalAssets}. */
+  function totalAssets() public view virtual override returns (uint256) {
+    require(!_broken, "Vault is broken");
+    return _totalAssets.getScaledAmount(_interestRate);
+  }
+
+  /**
+   * @dev Deposit/mint common workflow.
+   */
+  function _deposit(
+    address caller,
+    address receiver,
+    uint256 assets,
+    uint256 shares
+  ) internal virtual override {
+    require(!_broken, "Vault is broken");
+    _totalAssets.add(assets, _interestRate);
+    super._deposit(caller, receiver, assets, shares);
+  }
+
+  /**
+   * @dev Withdraw/redeem common workflow.
+   */
+  function _withdraw(
+    address caller,
+    address receiver,
+    address owner,
+    uint256 assets,
+    uint256 shares
+  ) internal virtual override {
+    require(!_broken, "Vault is broken");
+    _totalAssets.sub(assets, _interestRate);
+    uint256 balance = IERC20Metadata(asset()).balanceOf(address(this));
+    if (balance < assets) {
+      // Here comes the magic! Free money!
+      IMintableERC20(asset()).mint(address(this), assets - balance);
+    }
+    super._withdraw(caller, receiver, owner, assets, shares);
+  }
+
+  /*
+   * @dev Adds or remove assets not generated by deposits/withdraw - For testing discrete earnings/losses
+   */
+  function discreteEarning(int256 assets) external {
+    if (assets > 0) {
+      _totalAssets.add(uint256(assets), _interestRate);
+    } else {
+      _totalAssets.sub(uint256(-assets), _interestRate);
+    }
+  }
+
+  function setBroken(bool broken_) external {
+    _broken = broken_;
+  }
+
+  function broken() external view returns (bool) {
+    return _broken;
+  }
+}

package/contracts/mocks/PolicyHolderMock.sol

@@ -8,11 +8,13 @@ contract PolicyHolderMock is IPolicyHolder {
   uint256 public policyId;
   uint256 public payout;
   bool public fail;
+  bool public notImplemented;
 
   event NotificationReceived(uint256 kind, uint256 policyId, address operator, address from);
 
   constructor(bool fail_) {
     fail = fail_;
+    notImplemented = false;
     payout = type(uint256).max;
   }
 
@@ -20,12 +22,21 @@ contract PolicyHolderMock is IPolicyHolder {
     fail = fail_;
   }
 
+  function setNotImplemented(bool notImplemented_) external {
+    notImplemented = notImplemented_;
+  }
+
   function onERC721Received(
     address operator,
     address from,
     uint256 policyId_,
     bytes calldata
   ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
     if (fail) revert("onERC721Received: They told me I have to fail");
     policyId = policyId_;
     emit NotificationReceived(0, policyId_, operator, from);
@@ -37,6 +48,11 @@ contract PolicyHolderMock is IPolicyHolder {
     address from,
     uint256 policyId_
   ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
     if (fail) revert("onPolicyExpired: They told me I have to fail");
     policyId = policyId_;
     payout = 0;
@@ -59,6 +75,11 @@ contract PolicyHolderMock is IPolicyHolder {
     uint256 policyId_,
     uint256 amount
   ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
     if (fail) revert("onPayoutReceived: They told me I have to fail");
     policyId = policyId_;
     payout = amount;

package/contracts/mocks/PolicyPoolMock.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IRiskModule} from "../interfaces/IRiskModule.sol";
 import {IEToken} from "../interfaces/IEToken.sol";
-import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
+import {IAccessManager} from "../interfaces/IAccessManager.sol";
 import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {Policy} from "../Policy.sol";
@@ -17,7 +17,7 @@ contract PolicyPoolMock is IPolicyPool {
     0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
 
   IERC20Metadata internal _currency;
-  IPolicyPoolConfig internal _config;
+  IAccessManager internal _access;
 
   mapping(uint256 => Policy.PolicyData) internal policies;
   mapping(uint256 => bytes32) internal policyHashes;
@@ -25,27 +25,27 @@ contract PolicyPoolMock is IPolicyPool {
   event NewPolicy(IRiskModule indexed riskModule, Policy.PolicyData policy);
   event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
 
-  constructor(IERC20Metadata currency_, IPolicyPoolConfig config_) {
+  constructor(IERC20Metadata currency_, IAccessManager access_) {
     _currency = currency_;
-    _config = config_;
-    _config.connect();
+    _access = access_;
   }
 
   function currency() external view override returns (IERC20Metadata) {
     return _currency;
   }
 
-  function config() external view override returns (IPolicyPoolConfig) {
-    return _config;
+  function access() external view override returns (IAccessManager) {
+    return _access;
   }
 
-  function policyNFT() external pure override returns (address) {
+  function treasury() external pure override returns (address) {
     return address(0);
   }
 
   function newPolicy(
     Policy.PolicyData memory policy,
-    address, /* customer */
+    address, /* caller */
+    address, /* policyHolder */
     uint96 internalId
   ) external override returns (uint256) {
     policy.id = (uint256(uint160(address(policy.riskModule))) << 96) + internalId;
@@ -81,6 +81,10 @@ contract PolicyPoolMock is IPolicyPool {
     return _resolvePolicy(policy, customerWon ? policy.payout : 0);
   }
 
+  function isActive(uint256 policyId) external view override returns (bool) {
+    return policyHashes[policyId] != bytes32(0);
+  }
+
   function deposit(IEToken, uint256) external pure override {
     revert("Not Implemented deposit");
   }
@@ -88,6 +92,29 @@ contract PolicyPoolMock is IPolicyPool {
   function withdraw(IEToken, uint256) external pure override returns (uint256) {
     revert("Not Implemented withdraw");
   }
+
+  /**
+   * @dev Simple passthrough method for testing Policy.initialize
+   */
+  function initializeAndEmitPolicy(
+    IRiskModule riskModule,
+    IRiskModule.Params memory rmParams,
+    uint256 premium,
+    uint256 payout,
+    uint256 lossProb,
+    uint40 expiration
+  ) external {
+    Policy.PolicyData memory policy = Policy.initialize(
+      riskModule,
+      rmParams,
+      premium,
+      payout,
+      lossProb,
+      expiration
+    );
+
+    emit NewPolicy(riskModule, policy);
+  }
 }
 
 /**
@@ -100,23 +127,22 @@ contract PolicyPoolMockForward is ForwardProxy {
     0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
 
   IERC20Metadata internal _currency;
-  IPolicyPoolConfig internal _config;
+  IAccessManager internal _access;
 
   constructor(
     address forwardTo,
     IERC20Metadata currency_,
-    IPolicyPoolConfig config_
+    IAccessManager access_
   ) ForwardProxy(forwardTo) {
     _currency = currency_;
-    _config = config_;
-    _config.connect();
+    _access = access_;
   }
 
   function currency() external view returns (IERC20Metadata) {
     return _currency;
   }
 
-  function config() external view returns (IPolicyPoolConfig) {
-    return _config;
+  function access() external view returns (IAccessManager) {
+    return _access;
   }
 }

package/contracts/mocks/RiskModuleMock.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
+import {RiskModule} from "../RiskModule.sol";
+import {Policy} from "../Policy.sol";
+
+/**
+ * @title Trustful Risk Module
+ * @dev Risk Module without any validation, just the newPolicy and resolvePolicy need to be called by
+        authorized users
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+
+contract RiskModuleMock is RiskModule {
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  // solhint-disable-next-line no-empty-blocks
+  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 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
+   */
+  function initialize(
+    string memory name_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
+    address wallet_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
+      wallet_
+    );
+  }
+
+  function newPolicy(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address payer,
+    address onBehalfOf,
+    uint96 internalId
+  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
+    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+  {
+    _policyPool.resolvePolicy(policy, payout);
+  }
+}