@ensuro/core 1.2.7 → 2.0.0-beta1

package/contracts/mocks/ForwardProxy.sol

@@ -0,0 +1,66 @@
+//SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
+
+/**
+ * @dev This contract provides a fallback function that forwards all calls to another contract using the EVM
+ * instruction `call`.
+ *
+ * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
+ * different contract through the {_delegate} function.
+ *
+ * The success and return data of the delegated call will be returned back to the caller of the proxy.
+ */
+contract ForwardProxy is Proxy {
+  address internal _forwardTo;
+
+  constructor(address forwardTo) {
+    _forwardTo = forwardTo;
+  }
+
+  /**
+   * @dev Delegates the current call to `implementation`.
+   *
+   * This function does not return to its internall call site, it will return directly to the external caller.
+   */
+  function _delegate(address implementation) internal virtual override {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      // Copy msg.data. We take full control of memory in this inline assembly
+      // block because it will not return to Solidity code. We overwrite the
+      // Solidity scratch pad at memory position 0.
+      calldatacopy(0, 0, calldatasize())
+
+      // Call the implementation.
+      // out and outsize are 0 because we don't know the size yet.
+      // let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+      let result := call(gas(), implementation, 0, 0, calldatasize(), 0, 0)
+
+      // Copy the returned data.
+      returndatacopy(0, 0, returndatasize())
+
+      switch result
+      // delegatecall returns 0 on error.
+      case 0 {
+        revert(0, returndatasize())
+      }
+      default {
+        return(0, returndatasize())
+      }
+    }
+  }
+
+  /**
+   * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
+   * and {_fallback} should delegate.
+   */
+  function _implementation() internal view virtual override returns (address) {
+    return _forwardTo;
+  }
+
+  function setForwardTo(address forwardTo) external {
+    _forwardTo = forwardTo;
+  }
+}

package/contracts/mocks/IMintableERC20.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title IMintableERC20 interface
+ * @dev Interface for mintable / burnable ERC20 - for testing
+ * @author Ensuro
+ */
+interface IMintableERC20 {
+  function mint(address recipient, uint256 amount) external;
+
+  function burn(address recipient, uint256 amount) external;
+}

package/contracts/mocks/LinkTokenMock.sol

@@ -0,0 +1,30 @@
+//SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
+
+contract LinkTokenMock is ERC20 {
+  address public lastTransferTo;
+  uint256 public lastTransferValue;
+  bytes public lastTransferData;
+
+  constructor(
+    string memory name_,
+    string memory symbol_,
+    uint256 initialSupply
+  ) ERC20(name_, symbol_) {
+    _mint(msg.sender, initialSupply);
+  }
+
+  function transferAndCall(
+    address to,
+    uint256 value,
+    bytes calldata data
+  ) external returns (bool success) {
+    lastTransferTo = to;
+    lastTransferValue = value;
+    lastTransferData = data;
+    return true;
+  }
+}

package/contracts/mocks/PolicyHolderMock.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyHolder} from "../interfaces/IPolicyHolder.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+contract PolicyHolderMock is IPolicyHolder {
+  uint256 public policyId;
+  uint256 public payout;
+  bool public fail;
+
+  event NotificationReceived(uint256 kind, uint256 policyId, address operator, address from);
+
+  constructor(bool fail_) {
+    fail = fail_;
+    payout = type(uint256).max;
+  }
+
+  function setFail(bool fail_) external {
+    fail = fail_;
+  }
+
+  function onERC721Received(
+    address operator,
+    address from,
+    uint256 policyId_,
+    bytes calldata
+  ) external override returns (bytes4) {
+    if (fail) revert("onERC721Received: They told me I have to fail");
+    policyId = policyId_;
+    emit NotificationReceived(0, policyId_, operator, from);
+    return IERC721Receiver.onERC721Received.selector;
+  }
+
+  function onPolicyExpired(
+    address operator,
+    address from,
+    uint256 policyId_
+  ) external override returns (bytes4) {
+    if (fail) revert("onPolicyExpired: They told me I have to fail");
+    policyId = policyId_;
+    payout = 0;
+    emit NotificationReceived(1, policyId_, operator, from);
+    return IPolicyHolder.onPolicyExpired.selector;
+  }
+
+  /**
+   * @dev Whenever an Policy is resolved with payout > 0, this function is called
+   *
+   * It must return its Solidity selector to confirm the payout.
+   * If interface is not implemented by the recipient, it will be ignored and the payout will be successful.
+   * If any other value is returned or it reverts, the policy resolution / payout will be reverted.
+   *
+   * The selector can be obtained in Solidity with `IPolicyPool.onPayoutReceived.selector`.
+   */
+  function onPayoutReceived(
+    address operator,
+    address from,
+    uint256 policyId_,
+    uint256 amount
+  ) external override returns (bytes4) {
+    if (fail) revert("onPayoutReceived: They told me I have to fail");
+    policyId = policyId_;
+    payout = amount;
+    emit NotificationReceived(2, policyId_, operator, from);
+    return IPolicyHolder.onPayoutReceived.selector;
+  }
+}

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
+
+contract PolicyPoolComponentMock is IPolicyPoolComponent {
+  IPolicyPool internal immutable _policyPool;
+
+  constructor(IPolicyPool policyPool_) {
+    _policyPool = policyPool_;
+  }
+
+  function policyPool() external view override returns (IPolicyPool) {
+    return _policyPool;
+  }
+}

package/contracts/mocks/PolicyPoolMock.sol

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+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 {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {Policy} from "../Policy.sol";
+import {ForwardProxy} from "./ForwardProxy.sol";
+
+contract PolicyPoolMock is IPolicyPool {
+  using Policy for Policy.PolicyData;
+
+  uint256 public constant MAX_INT =
+    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+
+  IERC20Metadata internal _currency;
+  IPolicyPoolConfig internal _config;
+
+  mapping(uint256 => Policy.PolicyData) internal policies;
+  mapping(uint256 => bytes32) internal policyHashes;
+
+  event NewPolicy(IRiskModule indexed riskModule, Policy.PolicyData policy);
+  event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
+
+  constructor(IERC20Metadata currency_, IPolicyPoolConfig config_) {
+    _currency = currency_;
+    _config = config_;
+    _config.connect();
+  }
+
+  function currency() external view override returns (IERC20Metadata) {
+    return _currency;
+  }
+
+  function config() external view override returns (IPolicyPoolConfig) {
+    return _config;
+  }
+
+  function policyNFT() external pure override returns (address) {
+    return address(0);
+  }
+
+  function newPolicy(
+    Policy.PolicyData memory policy,
+    address, /* customer */
+    uint96 internalId
+  ) external override returns (uint256) {
+    policy.id = (uint256(uint160(address(policy.riskModule))) << 96) + internalId;
+    policyHashes[policy.id] = policy.hash();
+    emit NewPolicy(IRiskModule(msg.sender), policy);
+    return policy.id;
+  }
+
+  function _resolvePolicy(Policy.PolicyData memory policy, uint256 payout) internal {
+    require(policy.id != 0, "Policy not found");
+    require(policy.hash() == policyHashes[policy.id], "Hash doesn't match");
+    require(
+      msg.sender == address(policy.riskModule),
+      "Only riskModule is authorized to resolve the policy"
+    );
+    delete policies[policy.id];
+    delete policyHashes[policy.id];
+    emit PolicyResolved(IRiskModule(msg.sender), policy.id, payout);
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout) external override {
+    _resolvePolicy(policy, payout);
+  }
+
+  function expirePolicy(Policy.PolicyData calldata policy) external override {
+    _resolvePolicy(policy, 0);
+  }
+
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
+    external
+    override
+  {
+    return _resolvePolicy(policy, customerWon ? policy.payout : 0);
+  }
+
+  function deposit(IEToken, uint256) external pure override {
+    revert("Not Implemented deposit");
+  }
+
+  function withdraw(IEToken, uint256) external pure override returns (uint256) {
+    revert("Not Implemented withdraw");
+  }
+}
+
+/**
+ * @title PolicyPoolMockForward
+ * @dev PolicyPool that forwards fallback calls to another contract. Used to simulate calls to EToken
+ *      and other contracts that have functions that can be called only from PolicyPool
+ */
+contract PolicyPoolMockForward is ForwardProxy {
+  uint256 public constant MAX_INT =
+    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+
+  IERC20Metadata internal _currency;
+  IPolicyPoolConfig internal _config;
+
+  constructor(
+    address forwardTo,
+    IERC20Metadata currency_,
+    IPolicyPoolConfig config_
+  ) ForwardProxy(forwardTo) {
+    _currency = currency_;
+    _config = config_;
+    _config.connect();
+  }
+
+  function currency() external view returns (IERC20Metadata) {
+    return _currency;
+  }
+
+  function config() external view returns (IPolicyPoolConfig) {
+    return _config;
+  }
+}

package/contracts/mocks/TestCurrency.sol

@@ -0,0 +1,35 @@
+//SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IMintableERC20} from "./IMintableERC20.sol";
+
+contract TestCurrency is ERC20, IMintableERC20 {
+  address private _owner;
+  uint8 internal immutable _decimals;
+
+  constructor(
+    string memory name_,
+    string memory symbol_,
+    uint256 initialSupply,
+    uint8 decimals_
+  ) ERC20(name_, symbol_) {
+    _owner = msg.sender;
+    _decimals = decimals_;
+    _mint(msg.sender, initialSupply);
+  }
+
+  function decimals() public view virtual override returns (uint8) {
+    return _decimals;
+  }
+
+  function mint(address recipient, uint256 amount) external override {
+    // require(msg.sender == _owner, "Only owner can mint");
+    return _mint(recipient, amount);
+  }
+
+  function burn(address recipient, uint256 amount) external override {
+    // require(msg.sender == _owner, "Only owner can burn");
+    return _burn(recipient, amount);
+  }
+}

package/contracts/mocks/TestNFT.sol

@@ -0,0 +1,23 @@
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+pragma experimental ABIEncoderV2;
+
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract TestNFT is ERC721 {
+  address private _owner;
+
+  constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {
+    _owner = msg.sender;
+  }
+
+  function mint(address recipient, uint256 tokenId) public {
+    // require(msg.sender == _owner, "Only owner can mint");
+    return _mint(recipient, tokenId);
+  }
+
+  function burn(uint256 tokenId) public {
+    require(ERC721.ownerOf(tokenId) == msg.sender, "ERC721: burn of token that is not own");
+    return _burn(tokenId);
+  }
+}

package/contracts/upgraded/PolicyNFTv1.sol

@@ -5,7 +5,7 @@ import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/U
 import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
 import {CountersUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/CountersUpgradeable.sol";
 import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
-import {IPolicyPool} from "../../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {IPolicyNFTv1} from "./IPolicyNFTv1.sol";
 

package/js/test-utils.js

@@ -0,0 +1,278 @@
+const { expect } = require("chai");
+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");
+  let currency = await Currency.deploy(
+    options.name || "Test Currency",
+    options.symbol || "TEST",
+    options.initial_supply,
+    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]);
+  }));
+  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.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() {
+  return Math.floor(new Date().getTime() / 1000);
+}
+
+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]
+  });
+
+  await rm.deployed();
+
+  if (moc !== undefined && moc != 1.0) {
+    moc = _W(moc);
+    await rm.setParam(0, moc);
+  }
+  const policyPoolConfig = await hre.ethers.getContractAt("PolicyPoolConfig", await pool.config());
+  await policyPoolConfig.addRiskModule(rm.address);
+  return rm;
+}
+
+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]
+  });
+
+  await etk.deployed();
+  await pool.addEToken(etk.address);
+  return etk;
+}
+
+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;
+
+  if (setBalanceTo !== undefined)
+    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) {
+  // for each log in the transaction receipt
+  for (const log of receipt.events) {
+    let parsedLog;
+    try {
+      parsedLog = interface.parseLog(log);
+    } catch (error) {
+      continue;
+    }
+    if (parsedLog.name == eventName) {
+      return parsedLog;
+    }
+  }
+  return null;  // not found
+}
+
+exports.deployPool = async function(hre, options) {
+  const PolicyPool = await ethers.getContractFactory("PolicyPool");
+  const PolicyPoolConfig = await ethers.getContractFactory("PolicyPoolConfig");
+  const PolicyNFT = await ethers.getContractFactory("PolicyNFT");
+
+  // Deploy PolicyNFT
+  const policyNFT = await hre.upgrades.deployProxy(
+    PolicyNFT,
+    [
+      options.nftName || "Policy NFT",
+      options.nftSymbol || "EPOL",
+      options.policyPoolDetAddress || ethers.constants.AddressZero
+    ],
+    {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'});
+
+  await policyPoolConfig.deployed();
+
+  const policyPool = await hre.upgrades.deployProxy(PolicyPool, [], {
+    constructorArgs: [policyPoolConfig.address, policyNFT.address, options.currency],
+    kind: 'uups',
+    unsafeAllow: ["delegatecall"],
+  });
+
+  await policyPool.deployed();
+
+  for (const role of (options.grantRoles || [])) {
+    await grantRole(hre, policyPoolConfig, role);
+  }
+
+  await grantRole(hre, policyPoolConfig, "LEVEL1_ROLE");
+  await grantRole(hre, policyPoolConfig, "LEVEL2_ROLE");
+  await grantRole(hre, policyPoolConfig, "LEVEL3_ROLE");
+  return policyPool;
+}
+
+exports.deployPremiumsAccount = async function (hre, pool, options) {
+  const PremiumsAccount = await ethers.getContractFactory("PremiumsAccount");
+  const premiumsAccount = await hre.upgrades.deployProxy(PremiumsAccount, [], {
+    constructorArgs: [
+      pool.address,
+      options.jrEtkAddr || ethers.constants.AddressZero,
+      options.srEtkAddr || ethers.constants.AddressZero,
+    ],
+    kind: 'uups',
+    unsafeAllow: ["delegatecall"],
+  });
+
+  await premiumsAccount.deployed();
+  await pool.addPremiumsAccount(premiumsAccount.address);
+  return premiumsAccount;
+}
+
+async function _getDefaultSigner(hre) {
+  const signers = await hre.ethers.getSigners();
+  return signers[0];
+}
+
+async function grantRole(hre, contract, role, user) {
+  let userAddress;
+  if (user === undefined) {
+    user = await _getDefaultSigner(hre);
+    userAddress = user.address;
+  } else {
+    userAddress = user;
+  }
+  const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
+  if (!await contract.hasRole(roleHex, userAddress)) {
+    await contract.grantRole(roleHex, userAddress);
+  }
+}
+
+exports.grantRole = grantRole;
+
+async function grantComponentRole(hre, contract, component, role, user) {
+  let userAddress;
+  if (user === undefined) {
+    user = await _getDefaultSigner(hre);
+    userAddress = user.address;
+  } else {
+    userAddress = user;
+  }
+  const roleHex = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(role));
+  const componentRole = await contract.getComponentRole(component.address, roleHex);
+  if (!await contract.hasRole(componentRole, userAddress)) {
+    await contract.grantComponentRole(component.address, roleHex, userAddress);
+  }
+}
+
+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
+
+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));
+  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);
+  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) {
+      return _BN(value).mul(_BN(Math.pow(10, decimals)));
+    } else {
+      return _BN(Math.round(value * 1e6)).mul(_BN(Math.pow(10, decimals - 6)));
+    }
+  }
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ensuro/core",
   "description": "Ensuro - Decentralized insurance protocol",
-  "version": "1.2.7",
+  "version": "2.0.0-beta1",
   "files": [
     "**/*.sol",
     "/build/contracts/*.json",
     "/build/interfaces/*.json",
-    "!/mocks/**/*"
+    "/js/*.js"
   ],
   "repository": {
     "type": "git",