@ensuro/core 2.0.0-beta10 → 2.0.0-beta12

package/contracts/TrustfulRiskModule.sol

@@ -79,7 +79,57 @@ contract TrustfulRiskModule is RiskModule {
     address onBehalfOf,
     uint96 internalId
   ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
-    address payer = onBehalfOf;
+    return
+      _newPolicy(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _getPayer(onBehalfOf, premium),
+        onBehalfOf,
+        internalId
+      ).id;
+  }
+
+  /**
+   * @dev Creates a new Policy. Version that returns all the PolicyData struct, not just the id.
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(PRICER_ROLE)
+   *
+   * Emits:
+   * - {PolicyPool.NewPolicy}
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   * @param premium The premium that will be paid by the policyHolder
+   * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param expiration The expiration of the policy (timestamp)
+   * @param onBehalfOf The policy holder
+   * @param internalId An id that's unique within this module and it will be used to identify the policy
+   * @return createdPolicy Returns the id of the created policy
+   */
+  function newPolicyFull(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address onBehalfOf,
+    uint96 internalId
+  ) external onlyComponentRole(PRICER_ROLE) returns (Policy.PolicyData memory createdPolicy) {
+    return
+      _newPolicy(
+        payout,
+        premium,
+        lossProb,
+        expiration,
+        _getPayer(onBehalfOf, premium),
+        onBehalfOf,
+        internalId
+      );
+  }
+
+  function _getPayer(address onBehalfOf, uint256 premium) internal returns (address payer) {
+    payer = onBehalfOf;
     if (payer != _msgSender() && _policyPool.currency().allowance(payer, _msgSender()) < premium)
       /**
        * The standard is the payer should be the _msgSender() but usually, in this type of module,
@@ -93,8 +143,7 @@ contract TrustfulRiskModule is RiskModule {
        * premium even for multiple policies.
        */
       payer = _msgSender();
-
-    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
+    return payer;
   }
 
   /**
@@ -140,4 +189,11 @@ contract TrustfulRiskModule is RiskModule {
   {
     _policyPool.resolvePolicyFullPayout(policy, customerWon);
   }
+
+  /**
+   * @dev This empty reserved space is put in place to allow future versions to add new
+   * variables without shifting down storage in the inheritance chain.
+   * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
+   */
+  uint256[50] private __gap;
 }

package/contracts/interfaces/IAssetManager.sol

@@ -1,14 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
 /**
  * @title IAssetManager - Interface of the asset management strategy that's plugged into the reserves
  * @dev The asset manager is a contract that's plugged and called with `delegatecall` (operates in the context of the
  *      reserve - see {Reserve}). The asset manager contract applies a strategy to invest the reserve funds and
  *      get additional yields.
+ *
+ *      All implementations of this contract should use the Diamond Storage pattern to avoid overwriting the calling contract's state.
+ *      See https://eips.ethereum.org/EIPS/eip-2535#storage
  * @author Ensuro
  */
-interface IAssetManager {
+interface IAssetManager is IERC165 {
   /**
    * @dev Event emitted when funds are removed from Reserve liquidity and invested in the investment strategy,
    * @param amount The amount invested
@@ -57,8 +62,8 @@ interface IAssetManager {
   function recordEarnings() external returns (int256);
 
   /**
-   * @dev Refills the reserve balance with enought money to do a payment. Called from the reserve when a payment needs
-   * to be made and there's no enought liquid balance (`currency().balanceOf(reserve) < paymentAmount`)
+   * @dev Refills the reserve balance with enough money to do a payment. Called from the reserve when a payment needs
+   * to be made and there's no enough liquid balance (`currency().balanceOf(reserve) < paymentAmount`)
    *
    * Events:
    * - Emits {MoneyDeinvested} with the amount transferred to the liquid balance.

package/contracts/interfaces/IPolicyPool.sol

@@ -101,12 +101,23 @@ interface IPolicyPool {
   function expirePolicy(Policy.PolicyData calldata policy) external;
 
   /**
-   * @dev Returns whether or not a policy is active
-   * @param policyId The id of the policy we are querying
-   * @return Returns true if a policy with that id was created and wasn't yet resolved or expired, or false otherwise.
+   * @dev Returns whether a policy is active, i.e., it's still in the PolicyPool, not yet resolved or expired.
+   *      Be aware that a policy might be active but the `block.timestamp` might be after the expiration date, so it
+   *      can't be triggered with a payout.
+   *
+   * @param policyId The id of the policy queried
+   * @return Whether the policy is active or not
    */
   function isActive(uint256 policyId) external view returns (bool);
 
+  /**
+   * @dev Returns the stored hash of the policy. It's `bytes32(0)` is the policy isn't active.
+   *
+   * @param policyId The id of the policy queried
+   * @return Returns the hash of a given policy id
+   */
+  function getPolicyHash(uint256 policyId) external view returns (bytes32);
+
   /**
    * @dev Deposits liquidity into an eToken. Forwards the call to {EToken-deposit}, after transferring the funds.
    * The user will receive etokens for the same amount deposited.
@@ -137,7 +148,7 @@ interface IPolicyPool {
    *
    * @param eToken The address of the eToken from where the user wants to withdraw liquidity
    * @param amount The amount to withdraw. If equal to type(uint256).max, means full withdrawal.
-   *               If the balance is not enought or can't be withdrawn (locked as SCR), it withdraws
+   *               If the balance is not enough or can't be withdrawn (locked as SCR), it withdraws
    *               as much as it can, but doesn't fails.
    * @return Returns the actual amount withdrawn.
    */

package/contracts/interfaces/IPolicyPoolComponent.sol

@@ -2,13 +2,14 @@
 pragma solidity ^0.8.0;
 
 import {IPolicyPool} from "./IPolicyPool.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /**
  * @title IPolicyPoolComponent interface
  * @dev Interface for Contracts linked (owned) by a PolicyPool. Useful to avoid cyclic dependencies
  * @author Ensuro
  */
-interface IPolicyPoolComponent {
+interface IPolicyPoolComponent is IERC165 {
   /**
    * @dev Returns the address of the PolicyPool (see {PolicyPool}) where this component belongs.
    */

package/contracts/mocks/InterfaceIdCalculator.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
+import {IEToken} from "../interfaces/IEToken.sol";
+import {IRiskModule} from "../interfaces/IRiskModule.sol";
+import {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
+import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
+import {IAccessManager} from "../interfaces/IAccessManager.sol";
+import {IAssetManager} from "../interfaces/IAssetManager.sol";
+
+contract InterfaceIdCalculator {
+  bytes4 public constant IERC165_INTERFACEID = type(IERC165).interfaceId;
+  bytes4 public constant IERC20_INTERFACEID = type(IERC20).interfaceId;
+  bytes4 public constant IERC20METADATA_INTERFACEID = type(IERC20Metadata).interfaceId;
+  bytes4 public constant IERC721_INTERFACEID = type(IERC721).interfaceId;
+  bytes4 public constant IACCESSCONTROL_INTERFACEID = type(IAccessControl).interfaceId;
+  bytes4 public constant IPOLICYPOOL_INTERFACEID = type(IPolicyPool).interfaceId;
+  bytes4 public constant IPOLICYPOOLCOMPONENT_INTERFACEID = type(IPolicyPoolComponent).interfaceId;
+  bytes4 public constant IETOKEN_INTERFACEID = type(IEToken).interfaceId;
+  bytes4 public constant IRISKMODULE_INTERFACEID = type(IRiskModule).interfaceId;
+  bytes4 public constant IPREMIUMSACCOUNT_INTERFACEID = type(IPremiumsAccount).interfaceId;
+  bytes4 public constant ILPWHITELIST_INTERFACEID = type(ILPWhitelist).interfaceId;
+  bytes4 public constant IACCESSMANAGER_INTERFACEID = type(IAccessManager).interfaceId;
+  bytes4 public constant IASSETMANAGER_INTERFACEID = type(IAssetManager).interfaceId;
+}

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
 
@@ -14,4 +15,13 @@ contract PolicyPoolComponentMock is IPolicyPoolComponent {
   function policyPool() external view override returns (IPolicyPool) {
     return _policyPool;
   }
+
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   */
+  function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+    return
+      interfaceId == type(IERC165).interfaceId ||
+      interfaceId == type(IPolicyPoolComponent).interfaceId;
+  }
 }

package/contracts/mocks/PolicyPoolMock.sol

@@ -85,6 +85,10 @@ contract PolicyPoolMock is IPolicyPool {
     return policyHashes[policyId] != bytes32(0);
   }
 
+  function getPolicyHash(uint256 policyId) external view override returns (bytes32) {
+    return policyHashes[policyId];
+  }
+
   function deposit(IEToken, uint256) external pure override {
     revert("Not Implemented deposit");
   }