@ensuro/core 2.0.0-beta1 → 2.0.0-beta11

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

@@ -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);
+  }
+}