@ensuro/core 2.0.0-beta3 → 2.0.0-beta6

package/contracts/interfaces/{IPolicyPoolConfig.sol → IAccessManager.sol}

@@ -2,15 +2,13 @@
 pragma solidity ^0.8.0;
 
 import {IAccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import {ILPWhitelist} from "./ILPWhitelist.sol";
-import {IRiskModule} from "./IRiskModule.sol";
 
 /**
- * @title IPolicyPoolAccess - Interface for the contract that handles roles for the PolicyPool and components
+ * @title IAccessManager - Interface for the contract that handles roles for the PolicyPool and components
  * @dev Interface for the contract that handles roles for the PolicyPool and components
  * @author Ensuro
  */
-interface IPolicyPoolConfig is IAccessControlUpgradeable {
+interface IAccessManager is IAccessControlUpgradeable {
   enum GovernanceActions {
     none,
     setTreasury, // Changes PolicyPool treasury address
@@ -61,15 +59,6 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
     last
   }
 
-  enum RiskModuleStatus {
-    inactive, // newPolicy and resolvePolicy rejected
-    active, // newPolicy and resolvePolicy accepted
-    deprecated, // newPolicy rejected, resolvePolicy accepted
-    suspended // newPolicy and resolvePolicy rejected (temporarily)
-  }
-
-  event RiskModuleStatusChanged(IRiskModule indexed riskModule, RiskModuleStatus newStatus);
-
   function checkRole(bytes32 role, address account) external view;
 
   function checkComponentRole(
@@ -83,12 +72,4 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
     bytes32 role2,
     address account
   ) external view;
-
-  function connect() external;
-
-  function treasury() external view returns (address);
-
-  function checkAcceptsNewPolicy(IRiskModule riskModule) external view;
-
-  function checkAcceptsResolvePolicy(IRiskModule riskModule) external view;
 }

package/contracts/interfaces/IPolicyPool.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.0;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {Policy} from "../Policy.sol";
 import {IEToken} from "./IEToken.sol";
-import {IPolicyPoolConfig} from "./IPolicyPoolConfig.sol";
+import {IAccessManager} from "./IAccessManager.sol";
 
 interface IPolicyPool {
   /**
@@ -14,11 +14,10 @@ interface IPolicyPool {
   function currency() external view returns (IERC20Metadata);
 
   /**
-   * @dev Reference to the {PolicyPoolConfig} contract, this contract manages the access controls and installed risk
-   *      modules.
-   * @return The address of the PolicyPoolConfig contract
+   * @dev Reference to the {AccessManager} contract, this contract manages the access controls.
+   * @return The address of the AccessManager contract
    */
-  function config() external view returns (IPolicyPoolConfig);
+  function access() external view returns (IAccessManager);
 
   /**
    * @dev Reference to the {PolicyNFT} contract. This contract it's an ERC721 Token that handles the ownership of the
@@ -27,6 +26,12 @@ interface IPolicyPool {
    */
   function policyNFT() external view returns (address);
 
+  /**
+   * @dev Address of the treasury, that receives protocol fees.
+   * @return The address of the treasury
+   */
+  function treasury() external view returns (address);
+
   /**
    * @dev Creates a new Policy. Must be called from an active RiskModule
    *

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,24 +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) {
     return address(0);
   }
 
+  function treasury() external pure override returns (address) {
+    return address(0);
+  }
+
   function newPolicy(
     Policy.PolicyData memory policy,
     address, /* customer */
@@ -100,23 +103,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/js/test-utils.js

@@ -1,61 +1,84 @@
 const { expect } = require("chai");
 const { BigNumber } = require("ethers");
-const {LogDescription} = require("ethers/lib/utils");
+const { LogDescription } = require("ethers/lib/utils");
 exports.WEEK = 3600 * 24 * 7;
 exports.DAY = 3600 * 24;
 
-exports.initCurrency = async function(options, initial_targets, initial_balances) {
+exports.initCurrency = async function (options, initial_targets, initial_balances) {
   const Currency = await ethers.getContractFactory("TestCurrency");
   let currency = await Currency.deploy(
     options.name || "Test Currency",
     options.symbol || "TEST",
     options.initial_supply,
-    options.decimals || 18,
+    options.decimals || 18
   );
   initial_targets = initial_targets || [];
-  await Promise.all(initial_targets.map(async function (user, index) {
-    await currency.transfer(user.address, initial_balances[index]);
-  }));
+  await Promise.all(
+    initial_targets.map(async function (user, index) {
+      await currency.transfer(user.address, initial_balances[index]);
+    })
+  );
   return currency;
-}
+};
 
-exports.approve_multiple = async function(currency, spender, sources, amounts) {
-  return Promise.all(sources.map(async function (source, index) {
-    await currency.connect(source).approve(spender.address, amounts[index]);
-  }));
-}
+exports.approve_multiple = async function (currency, spender, sources, amounts) {
+  return Promise.all(
+    sources.map(async function (source, index) {
+      await currency.connect(source).approve(spender.address, amounts[index]);
+    })
+  );
+};
 
-exports.check_balances = async function(currency, users, amounts) {
-  return Promise.all(users.map(async function (user, index) {
-    expect(await currency.balanceOf(user.address)).to.equal(amounts[index]);
-  }));
-}
+exports.check_balances = async function (currency, users, amounts) {
+  return Promise.all(
+    users.map(async function (user, index) {
+      expect(await currency.balanceOf(user.address)).to.equal(amounts[index]);
+    })
+  );
+};
 
-exports.now = function() {
+exports.now = function () {
   return Math.floor(new Date().getTime() / 1000);
-}
-
-exports.addRiskModule = async function(pool, premiumsAccount, contractFactory, {
-      rmName, scrPercentage, scrInterestRate, ensuroFee, maxScrPerPolicy,
-      scrLimit, moc, wallet, extraArgs, extraConstructorArgs
-      }) {
+};
+
+exports.addRiskModule = async function (
+  pool,
+  premiumsAccount,
+  contractFactory,
+  {
+    rmName,
+    scrPercentage,
+    scrInterestRate,
+    ensuroFee,
+    maxScrPerPolicy,
+    scrLimit,
+    moc,
+    wallet,
+    extraArgs,
+    extraConstructorArgs,
+  }
+) {
   extraArgs = extraArgs || [];
   extraConstructorArgs = extraConstructorArgs || [];
   const _A = pool._A || _W;
-  const rm = await hre.upgrades.deployProxy(contractFactory, [
-    rmName || "RiskModule",
-    _W(scrPercentage) || _W(1),
-    _W(ensuroFee) || _W(0),
-    _W(scrInterestRate) || _W(0.1),
-    _A(maxScrPerPolicy) || _A(1000),
-    _A(scrLimit) || _A(1000000),
-    wallet || "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",  // Random address
-    ...extraArgs
-  ], {
-    kind: 'uups',
-    unsafeAllow: ["delegatecall"],
-    constructorArgs: [pool.address, premiumsAccount.address, ...extraConstructorArgs]
-  });
+  const rm = await hre.upgrades.deployProxy(
+    contractFactory,
+    [
+      rmName || "RiskModule",
+      _W(scrPercentage) || _W(1),
+      _W(ensuroFee) || _W(0),
+      _W(scrInterestRate) || _W(0.1),
+      _A(maxScrPerPolicy) || _A(1000),
+      _A(scrLimit) || _A(1000000),
+      wallet || "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC", // Random address
+      ...extraArgs,
+    ],
+    {
+      kind: "uups",
+      unsafeAllow: ["delegatecall"],
+      constructorArgs: [pool.address, premiumsAccount.address, ...extraConstructorArgs],
+    }
+  );
 
   await rm.deployed();
 
@@ -63,66 +86,63 @@ exports.addRiskModule = async function(pool, premiumsAccount, contractFactory, {
     moc = _W(moc);
     await rm.setParam(0, moc);
   }
-  const policyPoolConfig = await hre.ethers.getContractAt("PolicyPoolConfig", await pool.config());
-  await policyPoolConfig.addRiskModule(rm.address);
+  await pool.addRiskModule(rm.address);
   return rm;
-}
+};
 
-exports.addEToken = async function(pool, {
-      etkName, etkSymbol, maxUtilizationRate,
-      poolLoanInterestRate, extraArgs, extraConstructorArgs
-      }) {
+exports.addEToken = async function (
+  pool,
+  { etkName, etkSymbol, maxUtilizationRate, poolLoanInterestRate, extraArgs, extraConstructorArgs }
+) {
   const EToken = await ethers.getContractFactory("EToken");
   extraArgs = extraArgs || [];
   extraConstructorArgs = extraConstructorArgs || [];
-  const etk = await hre.upgrades.deployProxy(EToken, [
-    etkName || "EToken",
-    etkSymbol || "eUSD1YEAR",
-    _W(maxUtilizationRate) || _W(1),
-    _W(poolLoanInterestRate) || _W("0.05"),
-    ...extraArgs
-  ], {
-    kind: 'uups',
-    unsafeAllow: ["delegatecall"],
-    constructorArgs: [pool.address, ...extraConstructorArgs]
-  });
+  const etk = await hre.upgrades.deployProxy(
+    EToken,
+    [
+      etkName || "EToken",
+      etkSymbol || "eUSD1YEAR",
+      _W(maxUtilizationRate) || _W(1),
+      _W(poolLoanInterestRate) || _W("0.05"),
+      ...extraArgs,
+    ],
+    {
+      kind: "uups",
+      unsafeAllow: ["delegatecall"],
+      constructorArgs: [pool.address, ...extraConstructorArgs],
+    }
+  );
 
   await etk.deployed();
   await pool.addEToken(etk.address);
   return etk;
-}
+};
 
-exports.expected_change = async function(protocol_attribute, initial, change) {
+exports.expected_change = async function (protocol_attribute, initial, change) {
   change = BigNumber.from(change);
   let actual_value = await protocol_attribute();
   expect(actual_value.sub(initial)).to.equal(change);
   return actual_value;
-}
+};
 
-exports.impersonate = async function(address, setBalanceTo) {
-  const ok = await hre.network.provider.request(
-    {method: "hardhat_impersonateAccount", params: [address]}
-  );
-  if (!ok)
-    throw "Error impersonatting " + address;
+exports.impersonate = async function (address, setBalanceTo) {
+  const ok = await hre.network.provider.request({ method: "hardhat_impersonateAccount", params: [address] });
+  if (!ok) throw "Error impersonatting " + address;
 
   if (setBalanceTo !== undefined)
-    await hre.network.provider.request(
-      {method: "hardhat_setBalance", params: [address, setBalanceTo.toHexString()]}
-    );
+    await hre.network.provider.request({ method: "hardhat_setBalance", params: [address, setBalanceTo.toHexString()] });
 
   return await ethers.getSigner(address);
-}
-
+};
 
 /**
-* Finds an event in the receipt
-* @param {Interface} interface The interface of the contract that contains the requested event
-* @param {TransactionReceipt} receipt Transaction receipt containing the events in the logs
-* @param {String} eventName The name of the event we are interested in
-* @returns {LogDescription}
-*/
-exports.getTransactionEvent = function(interface, receipt, eventName) {
+ * Finds an event in the receipt
+ * @param {Interface} interface The interface of the contract that contains the requested event
+ * @param {TransactionReceipt} receipt Transaction receipt containing the events in the logs
+ * @param {String} eventName The name of the event we are interested in
+ * @returns {LogDescription}
+ */
+exports.getTransactionEvent = function (interface, receipt, eventName) {
   // for each log in the transaction receipt
   for (const log of receipt.events) {
     let parsedLog;
@@ -135,12 +155,12 @@ exports.getTransactionEvent = function(interface, receipt, eventName) {
       return parsedLog;
     }
   }
-  return null;  // not found
-}
+  return null; // not found
+};
 
-exports.deployPool = async function(hre, options) {
+exports.deployPool = async function (hre, options) {
   const PolicyPool = await ethers.getContractFactory("PolicyPool");
-  const PolicyPoolConfig = await ethers.getContractFactory("PolicyPoolConfig");
+  const AccessManager = await ethers.getContractFactory("AccessManager");
   const PolicyNFT = await ethers.getContractFactory("PolicyNFT");
 
   // Deploy PolicyNFT
@@ -149,37 +169,38 @@ exports.deployPool = async function(hre, options) {
     [
       options.nftName || "Policy NFT",
       options.nftSymbol || "EPOL",
-      options.policyPoolDetAddress || ethers.constants.AddressZero
+      options.policyPoolDetAddress || ethers.constants.AddressZero,
     ],
-    {kind: 'uups'}
+    { kind: "uups" }
   );
   await policyNFT.deployed();
 
-  // Deploy PolicyPoolConfig
-  const policyPoolConfig = await hre.upgrades.deployProxy(PolicyPoolConfig, [
-    options.policyPoolDetAddress || ethers.constants.AddressZero,
-    options.treasuryAddress || ethers.constants.AddressZero
-  ], {kind: 'uups'});
+  // Deploy AccessManager
+  const accessManager = await hre.upgrades.deployProxy(AccessManager, [], { kind: "uups" });
 
-  await policyPoolConfig.deployed();
+  await accessManager.deployed();
 
-  const policyPool = await hre.upgrades.deployProxy(PolicyPool, [], {
-    constructorArgs: [policyPoolConfig.address, policyNFT.address, options.currency],
-    kind: 'uups',
-    unsafeAllow: ["delegatecall"],
-  });
+  const policyPool = await hre.upgrades.deployProxy(
+    PolicyPool,
+    [options.treasuryAddress || ethers.constants.AddressZero],
+    {
+      constructorArgs: [accessManager.address, policyNFT.address, options.currency],
+      kind: "uups",
+      unsafeAllow: ["delegatecall"],
+    }
+  );
 
   await policyPool.deployed();
 
-  for (const role of (options.grantRoles || [])) {
-    await grantRole(hre, policyPoolConfig, role);
+  for (const role of options.grantRoles || []) {
+    await grantRole(hre, accessManager, role);
   }
 
-  await grantRole(hre, policyPoolConfig, "LEVEL1_ROLE");
-  await grantRole(hre, policyPoolConfig, "LEVEL2_ROLE");
-  await grantRole(hre, policyPoolConfig, "LEVEL3_ROLE");
+  await grantRole(hre, accessManager, "LEVEL1_ROLE");
+  await grantRole(hre, accessManager, "LEVEL2_ROLE");
+  await grantRole(hre, accessManager, "LEVEL3_ROLE");
   return policyPool;
-}
+};
 
 exports.deployPremiumsAccount = async function (hre, pool, options) {
   const PremiumsAccount = await ethers.getContractFactory("PremiumsAccount");
@@ -189,14 +210,14 @@ exports.deployPremiumsAccount = async function (hre, pool, options) {
       options.jrEtkAddr || ethers.constants.AddressZero,
       options.srEtkAddr || ethers.constants.AddressZero,
     ],
-    kind: 'uups',
+    kind: "uups",
     unsafeAllow: ["delegatecall"],
   });
 
   await premiumsAccount.deployed();
   await pool.addPremiumsAccount(premiumsAccount.address);
   return premiumsAccount;
-}
+};
 
 async function _getDefaultSigner(hre) {
   const signers = await hre.ethers.getSigners();
@@ -212,7 +233,7 @@ async function grantRole(hre, contract, role, user) {
     userAddress = user;
   }
   const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
-  if (!await contract.hasRole(roleHex, userAddress)) {
+  if (!(await contract.hasRole(roleHex, userAddress))) {
     await contract.grantRole(roleHex, userAddress);
   }
 }
@@ -229,7 +250,7 @@ async function grantComponentRole(hre, contract, component, role, user) {
   }
   const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
   const componentRole = await contract.getComponentRole(component.address, roleHex);
-  if (!await contract.hasRole(componentRole, userAddress)) {
+  if (!(await contract.hasRole(componentRole, userAddress))) {
     await contract.grantComponentRole(component.address, roleHex, userAddress);
   }
 }
@@ -239,40 +260,75 @@ exports.grantComponentRole = grantComponentRole;
 exports._E = ethers.utils.parseEther;
 
 const _BN = ethers.BigNumber.from;
-const WAD = _BN(1e10).mul(_BN(1e8));  // 1e10*1e8=1e18
-const RAY = WAD.mul(_BN(1e9));  // 1e18*1e9=1e27
+const WAD = _BN(1e10).mul(_BN(1e8)); // 1e10*1e8=1e18
+const RAY = WAD.mul(_BN(1e9)); // 1e18*1e9=1e27
 
 exports._BN = _BN;
 
-const _W = function(value) {
-  if (value === undefined)
-    return undefined;
-  if (!Number.isInteger(value))
-    return _BN(Math.round(value * 1e9)).mul(_BN(1e9));
+const _W = function (value) {
+  if (value === undefined) return undefined;
+  if (!Number.isInteger(value)) return _BN(Math.round(value * 1e9)).mul(_BN(1e9));
   return _BN(value).mul(WAD);
-}
+};
 
 exports._W = _W;
 
-const _R = function(value) {
-  if (value === undefined)
-    return undefined;
-  if (!Number.isInteger(value))
-    return _BN(Math.round(value * 1e9)).mul(WAD);
+const _R = function (value) {
+  if (value === undefined) return undefined;
+  if (!Number.isInteger(value)) return _BN(Math.round(value * 1e9)).mul(WAD);
   return _BN(value).mul(RAY);
-}
+};
 
 exports._R = _R;
 
 exports.amountFunction = function (decimals) {
   // Decimals must be at least 6
   return function (value) {
-    if (value === undefined)
-      return undefined;
-    if (typeof value === 'string' || value instanceof String) {
+    if (value === undefined) return undefined;
+    if (typeof value === "string" || value instanceof String) {
       return _BN(value).mul(_BN(Math.pow(10, decimals)));
     } else {
       return _BN(Math.round(value * 1e6)).mul(_BN(Math.pow(10, decimals - 6)));
     }
-  }
+  };
+};
+
+/*
+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)));
+
+  // 20 byte array
+  const bytesAddress = 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)));
 }
+
+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)}`;
+}
+
+exports.accessControlMessage = accessControlMessage;
+
+function makePolicyId(rm, internalId) {
+  return ethers.BigNumber.from(rm.address).shl(96).add(internalId);
+}
+
+exports.makePolicyId = makePolicyId;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ensuro/core",
   "description": "Ensuro - Decentralized insurance protocol",
-  "version": "2.0.0-beta3",
+  "version": "2.0.0-beta6",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",