@ensuro/core 2.0.0-beta7 → 2.0.0-beta9

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

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

package/contracts/mocks/RiskModuleMock.sol

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
-// SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
@@ -66,4 +65,11 @@ contract RiskModuleMock is RiskModule {
   ) 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);
+  }
 }

package/js/test-utils.js

@@ -1,11 +1,12 @@
 const { expect } = require("chai");
+const hre = require("hardhat");
 const { BigNumber } = require("ethers");
 const { LogDescription } = require("ethers/lib/utils");
 exports.WEEK = 3600 * 24 * 7;
 exports.DAY = 3600 * 24;
 
 exports.initCurrency = async function (options, initial_targets, initial_balances) {
-  const Currency = await ethers.getContractFactory("TestCurrency");
+  const Currency = await hre.ethers.getContractFactory("TestCurrency");
   let currency = await Currency.deploy(
     options.name || "Test Currency",
     options.symbol || "TEST",
@@ -94,7 +95,7 @@ exports.addEToken = async function (
   pool,
   { etkName, etkSymbol, maxUtilizationRate, poolLoanInterestRate, extraArgs, extraConstructorArgs }
 ) {
-  const EToken = await ethers.getContractFactory("EToken");
+  const EToken = await hre.ethers.getContractFactory("EToken");
   extraArgs = extraArgs || [];
   extraConstructorArgs = extraConstructorArgs || [];
   const etk = await hre.upgrades.deployProxy(
@@ -132,7 +133,7 @@ exports.impersonate = async function (address, setBalanceTo) {
   if (setBalanceTo !== undefined)
     await hre.network.provider.request({ method: "hardhat_setBalance", params: [address, setBalanceTo.toHexString()] });
 
-  return await ethers.getSigner(address);
+  return await hre.ethers.getSigner(address);
 };
 
 /**
@@ -161,8 +162,8 @@ const getTransactionEvent = function (interface, receipt, eventName) {
 exports.getTransactionEvent = getTransactionEvent;
 
 exports.deployPool = async function (hre, options) {
-  const PolicyPool = await ethers.getContractFactory("PolicyPool");
-  const AccessManager = await ethers.getContractFactory("AccessManager");
+  const PolicyPool = await hre.ethers.getContractFactory("PolicyPool");
+  const AccessManager = await hre.ethers.getContractFactory("AccessManager");
 
   // Deploy AccessManager
   const accessManager = await hre.upgrades.deployProxy(AccessManager, [], { kind: "uups" });
@@ -174,7 +175,7 @@ exports.deployPool = async function (hre, options) {
     [
       options.nftName || "Policy NFT",
       options.nftSymbol || "EPOL",
-      options.treasuryAddress || ethers.constants.AddressZero,
+      options.treasuryAddress || hre.ethers.constants.AddressZero,
     ],
     {
       constructorArgs: [accessManager.address, options.currency],
@@ -195,20 +196,22 @@ exports.deployPool = async function (hre, options) {
   return policyPool;
 };
 
-exports.deployPremiumsAccount = async function (hre, pool, options) {
-  const PremiumsAccount = await ethers.getContractFactory("PremiumsAccount");
+exports.deployPremiumsAccount = async function (hre, pool, options, addToPool = true) {
+  const PremiumsAccount = await hre.ethers.getContractFactory("PremiumsAccount");
   const premiumsAccount = await hre.upgrades.deployProxy(PremiumsAccount, [], {
     constructorArgs: [
       pool.address,
-      options.jrEtkAddr || ethers.constants.AddressZero,
-      options.srEtkAddr || ethers.constants.AddressZero,
+      options.jrEtkAddr || hre.ethers.constants.AddressZero,
+      options.srEtkAddr || hre.ethers.constants.AddressZero,
     ],
     kind: "uups",
     unsafeAllow: ["delegatecall"],
   });
 
   await premiumsAccount.deployed();
-  await pool.addComponent(premiumsAccount.address, 3);
+
+  if (addToPool) await pool.addComponent(premiumsAccount.address, 3);
+
   return premiumsAccount;
 };
 
@@ -225,9 +228,8 @@ async function grantRole(hre, contract, role, user) {
   } else {
     userAddress = user;
   }
-  const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
-  if (!(await contract.hasRole(roleHex, userAddress))) {
-    await contract.grantRole(roleHex, userAddress);
+  if (!(await contract.hasRole(getRole(role), userAddress))) {
+    await contract.grantRole(getRole(role), userAddress);
   }
 }
 
@@ -241,18 +243,17 @@ async function grantComponentRole(hre, accessManager, component, role, user) {
   } else {
     userAddress = user.address === undefined ? user : user.address;
   }
-  const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
-  const componentRole = await accessManager.getComponentRole(component.address, roleHex);
+  const componentRole = getComponentRole(component.address, getRole(role));
   if (!(await accessManager.hasRole(componentRole, userAddress))) {
-    await accessManager.grantComponentRole(component.address, roleHex, userAddress);
+    await accessManager.grantComponentRole(component.address, getRole(role), userAddress);
   }
 }
 
 exports.grantComponentRole = grantComponentRole;
 
-exports._E = ethers.utils.parseEther;
+exports._E = hre.ethers.utils.parseEther;
 
-const _BN = ethers.BigNumber.from;
+const _BN = hre.ethers.BigNumber.from;
 const WAD = _BN(1e10).mul(_BN(1e8)); // 1e10*1e8=1e18
 const RAY = WAD.mul(_BN(1e9)); // 1e18*1e9=1e27
 
@@ -286,27 +287,27 @@ exports.amountFunction = function (decimals) {
   };
 };
 
-/*
-Builds the component role identifier
-
-Mimics the behaviour of the PolicyPoolConfig.getComponentRole method
-
-Component roles are roles created doing XOR between the component
-address and the original role.
-
-Example:
-    getComponentRole("0xc6e7DF5E7b4f2A278906862b61205850344D4e7d", "ORACLE_ADMIN_ROLE")
-    // "0x05e01b185238b49f750d03d945e38a7f6c3be8b54de0ee42d481eb7814f0d3a8"
-*/
+/**
+ * Builds the component role identifier
+ *
+ * Mimics the behaviour of the PolicyPoolConfig.getComponentRole method
+ *
+ * Component roles are roles created doing XOR between the component
+ * address and the original role.
+ *
+ * Example:
+ *     getComponentRole("0xc6e7DF5E7b4f2A278906862b61205850344D4e7d", "ORACLE_ADMIN_ROLE")
+ *     // "0x05e01b185238b49f750d03d945e38a7f6c3be8b54de0ee42d481eb7814f0d3a8"
+ */
 function getComponentRole(componentAddress, roleName) {
   // 32 byte array
-  const bytesRole = ethers.utils.arrayify(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(roleName)));
+  const bytesRole = hre.ethers.utils.arrayify(getRole(roleName));
 
   // 20 byte array
-  const bytesAddress = ethers.utils.arrayify(componentAddress);
+  const bytesAddress = hre.ethers.utils.arrayify(componentAddress);
 
   // xor each byte, padding bytesAddress with zeros at the end
-  return ethers.utils.hexlify(bytesRole.map((elem, idx) => elem ^ (bytesAddress[idx] || 0)));
+  return hre.ethers.utils.hexlify(bytesRole.map((elem, idx) => elem ^ (bytesAddress[idx] || 0)));
 }
 
 exports.getComponentRole = getComponentRole;
@@ -315,13 +316,15 @@ exports.getComponentRole = getComponentRole;
 Builds AccessControl error message for comparison in tests
 */
 function accessControlMessage(address, component, role) {
-  return `AccessControl: account ${address.toLowerCase()} is missing role ${getComponentRole(component, role)}`;
+  const roleHash = component !== null ? getComponentRole(component, role) : getRole(role);
+
+  return `AccessControl: account ${address.toLowerCase()} is missing role ${roleHash}`;
 }
 
 exports.accessControlMessage = accessControlMessage;
 
 function makePolicyId(rm, internalId) {
-  return ethers.BigNumber.from(rm.address).shl(96).add(internalId);
+  return hre.ethers.BigNumber.from(rm.address).shl(96).add(internalId);
 }
 
 exports.makePolicyId = makePolicyId;
@@ -341,3 +344,13 @@ async function blockchainNow(owner) {
 }
 
 exports.blockchainNow = blockchainNow;
+
+function getRole(role) {
+  return role === "DEFAULT_ADMIN_ROLE"
+    ? "0x0000000000000000000000000000000000000000000000000000000000000000"
+    : hre.ethers.utils.keccak256(hre.ethers.utils.toUtf8Bytes(role));
+}
+
+exports.getRole = getRole;
+
+if (process.env.ENABLE_HH_WARNINGS !== "yes") hre.upgrades.silenceWarnings();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ensuro/core",
   "description": "Ensuro - Decentralized insurance protocol",
-  "version": "v2.0.0-beta7",
+  "version": "v2.0.0-beta9",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",

package/contracts/WadRayMath.sol

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.0;
-
-/**
- * @title WadRayMath library
- * @author Aave / Ensuro
- * @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays
- *      (decimals with 27 digits)
- * @custom:security-contact security@ensuro.co
- **/
-
-library WadRayMath {
-  uint256 internal constant WAD = 1e18;
-  uint256 internal constant HALF_WAD = WAD / 2;
-
-  uint256 internal constant RAY = 1e27;
-  uint256 internal constant HALF_RAY = RAY / 2;
-
-  uint256 internal constant WAD_RAY_RATIO = 1e9;
-
-  /**
-   * @return One ray, 1e27
-   **/
-  function ray() internal pure returns (uint256) {
-    return RAY;
-  }
-
-  /**
-   * @return One wad, 1e18
-   **/
-
-  function wad() internal pure returns (uint256) {
-    return WAD;
-  }
-
-  /**
-   * @return Half ray, 1e27/2
-   **/
-  function halfRay() internal pure returns (uint256) {
-    return HALF_RAY;
-  }
-
-  /**
-   * @return Half ray, 1e18/2
-   **/
-  function halfWad() internal pure returns (uint256) {
-    return HALF_WAD;
-  }
-
-  /**
-   * @dev Multiplies two wad, rounding half up to the nearest wad
-   * @param a Wad
-   * @param b Wad
-   * @return The result of a*b, in wad
-   **/
-  function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
-    if (a == 0 || b == 0) {
-      return 0;
-    }
-
-    require(a <= (type(uint256).max - HALF_WAD) / b, "wadMul: Math Multiplication Overflow");
-
-    return (a * b + HALF_WAD) / WAD;
-  }
-
-  /**
-   * @dev Divides two wad, rounding half up to the nearest wad
-   * @param a Wad
-   * @param b Wad
-   * @return The result of a/b, in wad
-   **/
-  function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
-    require(b != 0, "wadDiv: Division by zero");
-    uint256 halfB = b / 2;
-
-    require(a <= (type(uint256).max - halfB) / WAD, "wadDiv: Math Multiplication Overflow");
-
-    return (a * WAD + halfB) / b;
-  }
-
-  /**
-   * @dev Multiplies two ray, rounding half up to the nearest ray
-   * @param a Ray
-   * @param b Ray
-   * @return The result of a*b, in ray
-   **/
-  function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
-    if (a == 0 || b == 0) {
-      return 0;
-    }
-
-    require(a <= (type(uint256).max - HALF_RAY) / b, "rayMul: Math Multiplication Overflow");
-
-    return (a * b + HALF_RAY) / RAY;
-  }
-
-  /**
-   * @dev Divides two ray, rounding half up to the nearest ray
-   * @param a Ray
-   * @param b Ray
-   * @return The result of a/b, in ray
-   **/
-  function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
-    require(b != 0, "rayDiv: Division by zero");
-    uint256 halfB = b / 2;
-
-    require(a <= (type(uint256).max - halfB) / RAY, "rayDiv: Math Multiplication Overflow");
-
-    return (a * RAY + halfB) / b;
-  }
-
-  /**
-   * @dev Casts ray down to wad
-   * @param a Ray
-   * @return a casted to wad, rounded half up to the nearest wad
-   **/
-  function rayToWad(uint256 a) internal pure returns (uint256) {
-    uint256 halfRatio = WAD_RAY_RATIO / 2;
-    uint256 result = halfRatio + a;
-    require(result >= halfRatio, "rayToWad: Math Addition Overflow");
-
-    return result / WAD_RAY_RATIO;
-  }
-
-  /**
-   * @dev Converts wad up to ray
-   * @param a Wad
-   * @return a converted in ray
-   **/
-  function wadToRay(uint256 a) internal pure returns (uint256) {
-    uint256 result = a * WAD_RAY_RATIO;
-    require(result / WAD_RAY_RATIO == a, "wadToRad: Math Multiplication Overflow");
-    return result;
-  }
-}