@ensuro/core 1.2.0

package/contracts/dependencies/ChainlinkClientUpgradeable.sol

@@ -0,0 +1,371 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {Chainlink} from "@chainlink/contracts/src/v0.8/Chainlink.sol";
+import {ENSInterface} from "@chainlink/contracts/src/v0.8/interfaces/ENSInterface.sol";
+import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
+import {OperatorInterface} from "@chainlink/contracts/src/v0.8/interfaces/OperatorInterface.sol";
+import {PointerInterface} from "@chainlink/contracts/src/v0.8/interfaces/PointerInterface.sol";
+import {ENSResolver as ENSResolver_Chainlink} from "@chainlink/contracts/src/v0.8/vendor/ENSResolver.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/**
+ * @title The ChainlinkClient contract in upgradeable version
+ * @dev Changes to make it compatible with OZ UUPS proxies
+ * @notice Contract writers can inherit this contract in order to create requests for the
+ * Chainlink network
+ */
+contract ChainlinkClientUpgradeable is Initializable {
+  using Chainlink for Chainlink.Request;
+
+  uint256 constant internal LINK_DIVISIBILITY = 10**18;
+  uint256 constant private AMOUNT_OVERRIDE = 0;
+  address constant private SENDER_OVERRIDE = address(0);
+  uint256 constant private ORACLE_ARGS_VERSION = 1;
+  uint256 constant private OPERATOR_ARGS_VERSION = 2;
+  bytes32 constant private ENS_TOKEN_SUBNAME = keccak256("link");
+  bytes32 constant private ENS_ORACLE_SUBNAME = keccak256("oracle");
+  address constant private LINK_TOKEN_POINTER = 0xC89bD4E1632D3A43CB03AAAd5262cbe4038Bc571;
+
+  ENSInterface private ens;
+  bytes32 private ensNode;
+  LinkTokenInterface private link;
+  OperatorInterface private oracle;
+  uint256 private requestCount;
+  mapping(bytes32 => address) private pendingRequests;
+
+  event ChainlinkRequested(
+    bytes32 indexed id
+  );
+  event ChainlinkFulfilled(
+    bytes32 indexed id
+  );
+  event ChainlinkCancelled(
+    bytes32 indexed id
+  );
+
+  function __ChainlinkClient_init() internal initializer {
+    requestCount = 1;
+  }
+
+  /**
+   * @notice Creates a request that can hold additional parameters
+   * @param specId The Job Specification ID that the request will be created for
+   * @param callbackAddress The callback address that the response will be sent to
+   * @param callbackFunctionSignature The callback function signature to use for the callback address
+   * @return A Chainlink Request struct in memory
+   */
+  function buildChainlinkRequest(
+    bytes32 specId,
+    address callbackAddress,
+    bytes4 callbackFunctionSignature
+  )
+    internal
+    pure
+    returns (
+      Chainlink.Request memory
+    )
+  {
+    Chainlink.Request memory req;
+    return req.initialize(specId, callbackAddress, callbackFunctionSignature);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the stored oracle address
+   * @dev Calls `chainlinkRequestTo` with the stored oracle address
+   * @param req The initialized Chainlink Request
+   * @param payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function sendChainlinkRequest(
+    Chainlink.Request memory req,
+    uint256 payment
+  )
+    internal
+    returns (
+      bytes32
+    )
+  {
+    return sendChainlinkRequestTo(address(oracle), req, payment);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the specified oracle address
+   * @dev Generates and stores a request ID, increments the local nonce, and uses `transferAndCall` to
+   * send LINK which creates a request on the target oracle contract.
+   * Emits ChainlinkRequested event.
+   * @param oracleAddress The address of the oracle for the request
+   * @param req The initialized Chainlink Request
+   * @param payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function sendChainlinkRequestTo(
+    address oracleAddress,
+    Chainlink.Request memory req,
+    uint256 payment
+  )
+    internal
+    returns (
+      bytes32 requestId
+    )
+  {
+    return rawRequest(oracleAddress, req, payment, ORACLE_ARGS_VERSION, oracle.oracleRequest.selector);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the stored oracle address
+   * @dev This function supports multi-word response
+   * @dev Calls `requestOracleDataFrom` with the stored oracle address
+   * @param req The initialized Chainlink Request
+   * @param payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function requestOracleData(
+    Chainlink.Request memory req,
+    uint256 payment
+  )
+    internal
+    returns (
+      bytes32
+    )
+  {
+    return requestOracleDataFrom(address(oracle), req, payment);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the specified oracle address
+   * @dev This function supports multi-word response
+   * @dev Generates and stores a request ID, increments the local nonce, and uses `transferAndCall` to
+   * send LINK which creates a request on the target oracle contract.
+   * Emits ChainlinkRequested event.
+   * @param oracleAddress The address of the oracle for the request
+   * @param req The initialized Chainlink Request
+   * @param payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function requestOracleDataFrom(
+    address oracleAddress,
+    Chainlink.Request memory req,
+    uint256 payment
+  )
+    internal
+    returns (
+      bytes32 requestId
+    )
+  {
+    return rawRequest(oracleAddress, req, payment, OPERATOR_ARGS_VERSION, oracle.requestOracleData.selector);
+  }
+
+  /**
+   * @notice Make a request to an oracle
+   * @param oracleAddress The address of the oracle for the request
+   * @param req The initialized Chainlink Request
+   * @param payment The amount of LINK to send for the request
+   * @param argsVersion The version of data support (single word, multi word)
+   * @return requestId The request ID
+   */
+  function rawRequest(
+    address oracleAddress,
+    Chainlink.Request memory req,
+    uint256 payment,
+    uint256 argsVersion,
+    bytes4 funcSelector
+  )
+    private
+    returns (
+      bytes32 requestId
+    )
+  {
+    requestId = keccak256(abi.encodePacked(this, requestCount));
+    req.nonce = requestCount;
+    pendingRequests[requestId] = oracleAddress;
+    emit ChainlinkRequested(requestId);
+    bytes memory encodedData = abi.encodeWithSelector(
+      funcSelector,
+      SENDER_OVERRIDE, // Sender value - overridden by onTokenTransfer by the requesting contract's address
+      AMOUNT_OVERRIDE, // Amount value - overridden by onTokenTransfer by the actual amount of LINK sent
+      req.id,
+      req.callbackAddress,
+      req.callbackFunctionId,
+      req.nonce,
+      argsVersion,
+      req.buf.buf);
+    require(link.transferAndCall(oracleAddress, payment, encodedData), "unable to transferAndCall to oracle");
+    requestCount += 1;
+  }
+
+  /**
+   * @notice Allows a request to be cancelled if it has not been fulfilled
+   * @dev Requires keeping track of the expiration value emitted from the oracle contract.
+   * Deletes the request from the `pendingRequests` mapping.
+   * Emits ChainlinkCancelled event.
+   * @param requestId The request ID
+   * @param payment The amount of LINK sent for the request
+   * @param callbackFunc The callback function specified for the request
+   * @param expiration The time of the expiration for the request
+   */
+  function cancelChainlinkRequest(
+    bytes32 requestId,
+    uint256 payment,
+    bytes4 callbackFunc,
+    uint256 expiration
+  )
+    internal
+  {
+    OperatorInterface requested = OperatorInterface(pendingRequests[requestId]);
+    delete pendingRequests[requestId];
+    emit ChainlinkCancelled(requestId);
+    requested.cancelOracleRequest(requestId, payment, callbackFunc, expiration);
+  }
+
+  /**
+   * @notice Sets the stored oracle address
+   * @param oracleAddress The address of the oracle contract
+   */
+  function setChainlinkOracle(
+    address oracleAddress
+  )
+    internal
+  {
+    oracle = OperatorInterface(oracleAddress);
+  }
+
+  /**
+   * @notice Sets the LINK token address
+   * @param linkAddress The address of the LINK token contract
+   */
+  function setChainlinkToken(
+    address linkAddress
+  )
+    internal
+  {
+    link = LinkTokenInterface(linkAddress);
+  }
+
+  /**
+   * @notice Sets the Chainlink token address for the public
+   * network as given by the Pointer contract
+   */
+  function setPublicChainlinkToken()
+    internal
+  {
+    setChainlinkToken(PointerInterface(LINK_TOKEN_POINTER).getAddress());
+  }
+
+  /**
+   * @notice Retrieves the stored address of the LINK token
+   * @return The address of the LINK token
+   */
+  function chainlinkTokenAddress()
+    internal
+    view
+    returns (
+      address
+    )
+  {
+    return address(link);
+  }
+
+  /**
+   * @notice Retrieves the stored address of the oracle contract
+   * @return The address of the oracle contract
+   */
+  function chainlinkOracleAddress()
+    internal
+    view
+    returns (
+      address
+    )
+  {
+    return address(oracle);
+  }
+
+  /**
+   * @notice Allows for a request which was created on another contract to be fulfilled
+   * on this contract
+   * @param oracleAddress The address of the oracle contract that will fulfill the request
+   * @param requestId The request ID used for the response
+   */
+  function addChainlinkExternalRequest(
+    address oracleAddress,
+    bytes32 requestId
+  )
+    internal
+    notPendingRequest(requestId)
+  {
+    pendingRequests[requestId] = oracleAddress;
+  }
+
+  /**
+   * @notice Sets the stored oracle and LINK token contracts with the addresses resolved by ENS
+   * @dev Accounts for subnodes having different resolvers
+   * @param ensAddress The address of the ENS contract
+   * @param node The ENS node hash
+   */
+  function useChainlinkWithENS(
+    address ensAddress,
+    bytes32 node
+  )
+    internal
+  {
+    ens = ENSInterface(ensAddress);
+    ensNode = node;
+    bytes32 linkSubnode = keccak256(abi.encodePacked(ensNode, ENS_TOKEN_SUBNAME));
+    ENSResolver_Chainlink resolver = ENSResolver_Chainlink(ens.resolver(linkSubnode));
+    setChainlinkToken(resolver.addr(linkSubnode));
+    updateChainlinkOracleWithENS();
+  }
+
+  /**
+   * @notice Sets the stored oracle contract with the address resolved by ENS
+   * @dev This may be called on its own as long as `useChainlinkWithENS` has been called previously
+   */
+  function updateChainlinkOracleWithENS()
+    internal
+  {
+    bytes32 oracleSubnode = keccak256(abi.encodePacked(ensNode, ENS_ORACLE_SUBNAME));
+    ENSResolver_Chainlink resolver = ENSResolver_Chainlink(ens.resolver(oracleSubnode));
+    setChainlinkOracle(resolver.addr(oracleSubnode));
+  }
+
+  /**
+   * @notice Ensures that the fulfillment is valid for this contract
+   * @dev Use if the contract developer prefers methods instead of modifiers for validation
+   * @param requestId The request ID for fulfillment
+   */
+  function validateChainlinkCallback(
+    bytes32 requestId
+  )
+    internal
+    recordChainlinkFulfillment(requestId)
+    // solhint-disable-next-line no-empty-blocks
+  {}
+
+  /**
+   * @dev Reverts if the sender is not the oracle of the request.
+   * Emits ChainlinkFulfilled event.
+   * @param requestId The request ID for fulfillment
+   */
+  modifier recordChainlinkFulfillment(
+    bytes32 requestId
+  )
+  {
+    require(msg.sender == pendingRequests[requestId],
+            "Source must be the oracle of the request");
+    delete pendingRequests[requestId];
+    emit ChainlinkFulfilled(requestId);
+    _;
+  }
+
+  /**
+   * @dev Reverts if the request is already pending
+   * @param requestId The request ID for fulfillment
+   */
+  modifier notPendingRequest(
+    bytes32 requestId
+  )
+  {
+    require(pendingRequests[requestId] == address(0), "Request is already pending");
+    _;
+  }
+}

package/contracts/upgraded/IPolicyNFTv1.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+
+/**
+ * @title IPolicyNFT interface
+ * @dev Interface for mintable NFT token that returns tokenId
+ * @author Ensuro
+ */
+interface IPolicyNFTv1 is IERC721Upgradeable {
+  function safeMint(address to) external returns (uint256);
+
+  function connect() external;
+}

package/contracts/upgraded/PolicyNFTv1.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.2;
+
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+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 {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IPolicyNFTv1} from "./IPolicyNFTv1.sol";
+
+/**
+ * @title PolicyNFT - NFT that keeps track of issued policies and its owners
+ * @dev Every time a new policy is accepted by the PolicyPool, a new NFT is minted generating a new
+ *      policyId owned by the customer. Only the PolicyPool can mint NFTs.
+ *      After creation, NFTs can be transferred in the ERC721 standard way and that changes the policy holder.
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract PolicyNFTv1 is UUPSUpgradeable, ERC721Upgradeable, PausableUpgradeable, IPolicyNFTv1 {
+  using CountersUpgradeable for CountersUpgradeable.Counter;
+
+  bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+  bytes32 public constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
+
+  CountersUpgradeable.Counter private _tokenIdCounter;
+  IPolicyPool internal _policyPool;
+
+  modifier onlyPolicyPool() {
+    require(_msgSender() == address(_policyPool), "The caller must be the PolicyPool");
+    _;
+  }
+
+  modifier onlyPoolRole2(bytes32 role1, bytes32 role2) {
+    _policyPool.config().checkRole2(role1, role2, msg.sender);
+    _;
+  }
+
+  modifier onlyPoolRole(bytes32 role) {
+    _policyPool.config().checkRole(role, msg.sender);
+    _;
+  }
+
+  function initialize(
+    string memory name_,
+    string memory symbol_,
+    IPolicyPool policyPool_
+  ) public initializer {
+    __UUPSUpgradeable_init();
+    __Pausable_init();
+    __ERC721_init(name_, symbol_);
+    __PolicyNFT_init_unchained(policyPool_);
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function __PolicyNFT_init_unchained(IPolicyPool policyPool_) internal initializer {
+    _policyPool = policyPool_;
+    _tokenIdCounter.increment(); // I don't want _tokenId==0
+  }
+
+  // solhint-disable-next-line no-empty-blocks
+  function _authorizeUpgrade(address) internal override onlyPoolRole2(GUARDIAN_ROLE, LEVEL1_ROLE) {}
+
+  function pause() public onlyPoolRole(GUARDIAN_ROLE) {
+    _pause();
+  }
+
+  function unpause() public onlyPoolRole2(GUARDIAN_ROLE, LEVEL1_ROLE) {
+    _unpause();
+  }
+
+  /**
+   * @dev This function can be called only once in contract's lifetime. It links the NFT with the
+   *      PolicyPool contract. It's called in PolicyPool initialization.
+   */
+  function connect() external override {
+    require(
+      address(_policyPool) == address(0) || address(_policyPool) == _msgSender(),
+      "PolicyPool already connected"
+    );
+    _policyPool = IPolicyPool(_msgSender());
+    // Not possible to do this validation because connect is called in _policyPool initialize :'(
+    // require(_policyPool.policyNFT() == address(this), "PolicyPool not connected to this config");
+  }
+
+  function safeMint(address to)
+    external
+    virtual
+    override
+    onlyPolicyPool
+    whenNotPaused
+    returns (uint256)
+  {
+    uint256 tokenId = _tokenIdCounter.current();
+    _safeMint(to, tokenId);
+    _tokenIdCounter.increment();
+    return tokenId;
+  }
+
+  function _beforeTokenTransfer(
+    address from,
+    address to,
+    uint256 tokenId
+  ) internal override whenNotPaused {
+    super._beforeTokenTransfer(from, to, tokenId);
+  }
+
+  function nextId() external view returns (uint256) {
+    return _tokenIdCounter.current();
+  }
+}
+
+// solhint-disable-next-line contract-name-camelcase
+contract PolicyNFTv1_Upgrade is PolicyNFTv1 {
+  function safeMint(address to, uint256 policyId) external onlyPolicyPool whenNotPaused {
+    _safeMint(to, policyId, "");
+  }
+
+  function safeMint(address) external view override onlyPolicyPool whenNotPaused returns (uint256) {
+    revert("Not supported anymore");
+  }
+
+  function policyPool() external view returns (IPolicyPool) {
+    return _policyPool;
+  }
+}

package/interfaces/IAssetManager.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title IAssetManager interface
+ * @dev Interface for asset manager, that manages assets and refills pool wallet when needed
+ * @author Ensuro
+ */
+interface IAssetManager {
+  /**
+   * @dev This is called from PolicyPool when doesn't have enought money for payment.
+   *      After the call, there should be enought money in PolicyPool.currency().balanceOf(_policyPool) to
+   *      do the payment
+   * @param paymentAmount The amount of the payment
+   */
+  function refillWallet(uint256 paymentAmount) external;
+
+  /**
+   * @dev Deinvest all the assets and return the cash back to the PolicyPool.
+   *      Called from PolicyPool when new asset manager is assigned
+   */
+  function deinvestAll() external;
+}

package/interfaces/IEToken.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @title IEToken interface
+ * @dev Interface for EToken smart contracts, these are the capital pools.
+ * @author Ensuro
+ */
+interface IEToken is IERC20 {
+  event SCRLocked(uint256 interestRate, uint256 value);
+  event SCRUnlocked(uint256 interestRate, uint256 value);
+
+  function ocean() external view returns (uint256);
+
+  function oceanForNewScr() external view returns (uint256);
+
+  function scr() external view returns (uint256);
+
+  function lockScr(uint256 policyInterestRate, uint256 scrAmount) external;
+
+  function unlockScr(uint256 policyInterestRate, uint256 scrAmount) external;
+
+  function discreteEarning(uint256 amount, bool positive) external;
+
+  function assetEarnings(uint256 amount, bool positive) external;
+
+  function deposit(address provider, uint256 amount) external returns (uint256);
+
+  function totalWithdrawable() external view returns (uint256);
+
+  function withdraw(address provider, uint256 amount) external returns (uint256);
+
+  function accepts(address riskModule, uint40 policyExpiration) external view returns (bool);
+
+  function lendToPool(uint256 amount, bool fromOcean) external returns (uint256);
+
+  function repayPoolLoan(uint256 amount) external;
+
+  function getPoolLoan() external view returns (uint256);
+
+  function getInvestable() external view returns (uint256);
+}

package/interfaces/IInsolvencyHook.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IEToken} from "./IEToken.sol";
+
+/**
+ * @title IInsolvencyHook interface
+ * @dev Interface for insolvency hook, the contract that manages the insolvency situation of the pool
+ * @author Ensuro
+ */
+interface IInsolvencyHook {
+  /**
+   * @dev This is called from PolicyPool when doesn't have enought money for payment.
+   *      After the call, there should be enought money in PolicyPool.currency().balanceOf(_policyPool) to
+   *      do the payment
+   * @param paymentAmount The amount of the payment
+   */
+  function outOfCash(uint256 paymentAmount) external;
+
+  /**
+   * @dev This is called from EToken when doesn't have enought totalSupply to cover the SCR
+   *      The hook might choose not to do anything or solve the insolvency with a deposit
+   * @param eToken The token that suffers insolvency
+   * @param paymentAmount The amount of the payment
+   */
+  function insolventEToken(IEToken eToken, uint256 paymentAmount) external;
+}

package/interfaces/ILPWhitelist.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IEToken} from "./IEToken.sol";
+
+/**
+ * @title ILPWhitelist - Interface that handles the whitelisting of Liquidity Providers
+ * @author Ensuro
+ */
+interface ILPWhitelist {
+  function acceptsDeposit(
+    IEToken etoken,
+    address provider,
+    uint256 amount
+  ) external view returns (bool);
+
+  function acceptsTransfer(
+    IEToken etoken,
+    address providerFrom,
+    address providerTo,
+    uint256 amount
+  ) external view returns (bool);
+}

package/interfaces/IPolicyNFT.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+
+/**
+ * @title IPolicyNFT interface
+ * @dev Interface for mintable NFT token that returns tokenId
+ * @author Ensuro
+ */
+interface IPolicyNFT is IERC721Upgradeable {
+  function safeMint(address to, uint256 policyId) external;
+
+  function connect() external;
+}

package/interfaces/IPolicyPool.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {Policy} from "../contracts/Policy.sol";
+import {IEToken} from "./IEToken.sol";
+import {IPolicyPoolConfig} from "./IPolicyPoolConfig.sol";
+import {IAssetManager} from "./IAssetManager.sol";
+
+interface IPolicyPool {
+  function currency() external view returns (IERC20Metadata);
+
+  function config() external view returns (IPolicyPoolConfig);
+
+  function policyNFT() external view returns (address);
+
+  function setAssetManager(IAssetManager newAssetManager) external;
+
+  function newPolicy(
+    Policy.PolicyData memory policy,
+    address customer,
+    uint96 internalId
+  ) external returns (uint256);
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout) external;
+
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon) external;
+
+  function receiveGrant(uint256 amount) external;
+
+  function getInvestable() external view returns (uint256);
+
+  function getETokenCount() external view returns (uint256);
+
+  function getETokenAt(uint256 index) external view returns (IEToken);
+
+  function assetEarnings(uint256 amount, bool positive) external;
+
+  function deposit(IEToken eToken, uint256 amount) external;
+
+  function withdraw(IEToken eToken, uint256 amount) external returns (uint256);
+
+  function totalETokenSupply() external view returns (uint256);
+}