@ensuro/core 1.2.0

package/contracts/FlightDelayRiskModule.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {Policy} from "./Policy.sol";
+import {RiskModule} from "./RiskModule.sol";
+import {Chainlink} from "@chainlink/contracts/src/v0.8/Chainlink.sol";
+import {ChainlinkClientUpgradeable} from "./dependencies/ChainlinkClientUpgradeable.sol";
+
+/**
+ * @title Flight Delay Risk Module
+ * @dev Risk Module that resolves policy based in actualarrivaldate of flight
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract FlightDelayRiskModule is RiskModule, ChainlinkClientUpgradeable {
+  using Chainlink for Chainlink.Request;
+
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 public constant ORACLE_ADMIN_ROLE = keccak256("ORACLE_ADMIN_ROLE");
+  // Multiplier to calculate expiration = expectedArrival + tolerance + delayTime * DELAY_EXPIRATION_TIMES
+  uint40 public constant DELAY_EXPIRATION_TIMES = 5;
+
+  struct PolicyData {
+    Policy.PolicyData ensuroPolicy;
+    string flight;
+    uint40 departure;
+    uint40 expectedArrival;
+    uint40 tolerance;
+  }
+
+  struct OracleParams {
+    address oracle;
+    uint96 delayTime;
+    uint256 fee;
+    bytes16 dataJobId;
+    bytes16 sleepJobId;
+  }
+
+  OracleParams internal _oracleParams;
+
+  mapping(bytes32 => uint256) internal _pendingQueries;
+  mapping(uint256 => PolicyData) internal _policies;
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  // solhint-disable-next-line no-empty-blocks
+  constructor(IPolicyPool policyPool_) RiskModule(policyPool_) {}
+
+  /**
+   * @dev Initializes the RiskModule
+   * @param name_ Name of the Risk Module
+   * @param scrPercentage_ Solvency Capital Requirement percentage, to calculate
+                           capital requirement as % of (payout - premium)  (in ray)
+   * @param ensuroFee_ % of premium that will go for Ensuro treasury (in ray)
+   * @param scrInterestRate_ cost of capital (in ray)
+   * @param maxScrPerPolicy_ Max SCR to be allocated to this module (in wad)
+   * @param scrLimit_ Max SCR to be allocated to this module (in wad)
+   * @param wallet_ Address of the RiskModule provider
+   * @param linkToken_ Address of ChainLink LINK token
+   * @param oracleParams_ Parameters of the Oracle
+   */
+  function initialize(
+    string memory name_,
+    uint256 scrPercentage_,
+    uint256 ensuroFee_,
+    uint256 scrInterestRate_,
+    uint256 maxScrPerPolicy_,
+    uint256 scrLimit_,
+    address wallet_,
+    address linkToken_,
+    OracleParams memory oracleParams_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      scrPercentage_,
+      ensuroFee_,
+      scrInterestRate_,
+      maxScrPerPolicy_,
+      scrLimit_,
+      wallet_
+    );
+    __ChainlinkClient_init();
+    __FlightDelayRiskModule_init_unchained(linkToken_, oracleParams_);
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function __FlightDelayRiskModule_init_unchained(
+    address linkToken_,
+    OracleParams memory oracleParams_
+  ) internal initializer {
+    setChainlinkToken(linkToken_);
+    _oracleParams = oracleParams_;
+  }
+
+  function setOracleParams(OracleParams memory newParams) external onlyRole(ORACLE_ADMIN_ROLE) {
+    _oracleParams = newParams;
+  }
+
+  function oracleParams() external view returns (OracleParams memory) {
+    return _oracleParams;
+  }
+
+  /**
+   * @dev Creates a new policy
+   * @param flight Flight Number as String (ex: NAX105)
+   * @param departure Departure in epoch seconds (ex: 1631817600)
+   * @param expectedArrival Expected arrival in epoch seconds (ex: 1631824800)
+   * @param tolerance In seconds, the tolerance margin after expectedArrival before trigger the policy
+   * @param payout Payout for customer in case policy is triggered
+   * @param premium Premium the customer pays
+   * @param lossProb Probability of policy being triggered
+   * @param customer Customer address (to take premium from and send payout)
+   */
+  function newPolicy(
+    string memory flight,
+    uint40 departure,
+    uint40 expectedArrival,
+    uint40 tolerance,
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    address customer,
+    uint96 internalId
+  ) external onlyRole(PRICER_ROLE) returns (uint256) {
+    require(expectedArrival > block.timestamp, "expectedArrival can't be in the past");
+    require(departure != 0 && expectedArrival > departure, "expectedArrival <= departure!");
+    uint40 expiration = expectedArrival +
+      tolerance +
+      uint40(_oracleParams.delayTime) *
+      DELAY_EXPIRATION_TIMES;
+    Policy.PolicyData memory ensuroPolicy = _newPolicy(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      customer,
+      internalId
+    );
+    PolicyData storage policy = _policies[ensuroPolicy.id];
+    policy.ensuroPolicy = ensuroPolicy;
+    policy.flight = flight;
+    policy.departure = departure;
+    policy.expectedArrival = expectedArrival;
+    policy.tolerance = tolerance;
+
+    uint256 until = expectedArrival + tolerance + uint256(_oracleParams.delayTime);
+    _chainlinkRequest(ensuroPolicy.id, policy, until);
+    return ensuroPolicy.id;
+  }
+
+  function _chainlinkRequest(
+    uint256 policyId,
+    PolicyData storage policy,
+    uint256 until
+  ) internal {
+    // request takes a JobID, a callback address, and callback function as input
+    Chainlink.Request memory req = buildChainlinkRequest(
+      until == 0 ? _oracleParams.dataJobId : _oracleParams.sleepJobId,
+      address(this),
+      this.fulfill.selector
+    );
+    req.add("flight", policy.flight);
+    req.add("endpoint", "actualarrivaldate");
+    req.addUint("departure", policy.departure);
+    if (until > 0) {
+      req.addUint("until", until);
+    }
+
+    // Sends the request with the amount of payment specified to the oracle
+    // (results will arrive with the callback = later)
+    bytes32 queryId = sendChainlinkRequestTo(_oracleParams.oracle, req, _oracleParams.fee);
+    _pendingQueries[queryId] = policyId;
+  }
+
+  /**
+   * @dev Forces the resolution of the policy (without waiting Chainlink scheduled on creation)
+   * @param policyId The id of the policy previously created (in newPolicy)
+   */
+  function resolvePolicy(uint256 policyId) external onlyRole(PRICER_ROLE) returns (uint256) {
+    PolicyData storage policy = _policies[policyId];
+    require(policy.expectedArrival != 0, "Policy not found!");
+    _chainlinkRequest(policyId, policy, 0);
+    return policyId;
+  }
+
+  function fulfill(bytes32 queryId, int256 actualArrivalDate)
+    public
+    recordChainlinkFulfillment(queryId)
+  {
+    uint256 policyId = _pendingQueries[queryId];
+    require(policyId != 0, "queryId not found!");
+    PolicyData storage policy = _policies[policyId];
+
+    if (actualArrivalDate == 0) {
+      if (block.timestamp > (policy.expectedArrival + policy.tolerance)) {
+        // Treat as arrived after tolerance
+        actualArrivalDate = int256(uint256((policy.expectedArrival + policy.tolerance) + 1));
+      } else {
+        // Not arrived yet
+        return;
+      }
+    }
+    bool customerWon = (actualArrivalDate <= 0 || // cancelled
+      uint256(actualArrivalDate) > uint256(policy.expectedArrival + policy.tolerance)); // arrived after tolerance
+
+    _policyPool.resolvePolicyFullPayout(policy.ensuroPolicy, customerWon);
+  }
+}

package/contracts/LPManualWhitelist.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
+import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
+import {IEToken} from "../interfaces/IEToken.sol";
+
+/**
+ * @title Manual Whitelisting contract
+ * @dev LP addresses are whitelisted (and un-whitelisted) manually with transactions by user with given role
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract LPManualWhitelist is ILPWhitelist, PolicyPoolComponent {
+  bytes32 public constant LP_WHITELIST_ROLE = keccak256("LP_WHITELIST_ROLE");
+
+  mapping(address => bool) private _whitelisted;
+
+  event LPWhitelisted(address provider, bool whitelisted);
+
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  // solhint-disable-next-line no-empty-blocks
+  constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
+
+  /**
+   * @dev Initializes the Whitelist contract
+   */
+  function initialize() public initializer {
+    __PolicyPoolComponent_init();
+  }
+
+  function whitelistAddress(address provider, bool whitelisted)
+    external
+    onlyPoolRole(LP_WHITELIST_ROLE)
+  {
+    _whitelisted[provider] = whitelisted;
+    emit LPWhitelisted(provider, whitelisted);
+  }
+
+  function acceptsDeposit(
+    IEToken,
+    address provider,
+    uint256
+  ) external view override returns (bool) {
+    return _whitelisted[provider];
+  }
+
+  function acceptsTransfer(
+    IEToken,
+    address,
+    address providerTo,
+    uint256
+  ) external view override returns (bool) {
+    return _whitelisted[providerTo];
+  }
+}

package/contracts/Policy.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+import {WadRayMath} from "./WadRayMath.sol";
+import {IRiskModule} from "../interfaces/IRiskModule.sol";
+
+/**
+ * @title Policy library
+ * @dev Library for PolicyData struct. This struct represents an active policy, how the premium is
+ *      distributed, the probability of payout, duration and how the capital is locked.
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+library Policy {
+  using WadRayMath for uint256;
+
+  uint256 internal constant SECONDS_IN_YEAR = 31536000e18; /* 365 * 24 * 3600 * 10e18 */
+  uint256 internal constant SECONDS_IN_YEAR_RAY = 31536000e27; /* 365 * 24 * 3600 * 10e27 */
+
+  // Active Policies
+  struct PolicyData {
+    uint256 id;
+    uint256 payout;
+    uint256 premium;
+    uint256 scr;
+    uint256 lossProb; // original loss probability (in ray)
+    uint256 purePremium; // share of the premium that covers expected losses
+    // equal to payout * lossProb * riskModule.moc
+    uint256 premiumForEnsuro; // share of the premium that goes for Ensuro (if policy won)
+    uint256 premiumForRm; // share of the premium that goes for the RM (if policy won)
+    uint256 premiumForLps; // share of the premium that goes to the liquidity providers (won or not)
+    IRiskModule riskModule;
+    uint40 start;
+    uint40 expiration;
+  }
+
+  /// #if_succeeds {:msg "premium preserved"} premium == (newPolicy.premium);
+  /// #if_succeeds
+  ///    {:msg "premium distributed"}
+  ///    premium == (newPolicy.purePremium + newPolicy.premiumForLps +
+  ///                newPolicy.premiumForRm + newPolicy.premiumForEnsuro);
+  function initialize(
+    IRiskModule riskModule,
+    uint256 premium,
+    uint256 payout,
+    uint256 lossProb,
+    uint40 expiration
+  ) internal view returns (PolicyData memory newPolicy) {
+    require(premium <= payout, "Premium cannot be more than payout");
+    PolicyData memory policy;
+    policy.riskModule = riskModule;
+    policy.premium = premium;
+    policy.payout = payout;
+    policy.lossProb = lossProb;
+    policy.purePremium = payout.wadToRay().rayMul(lossProb.rayMul(riskModule.moc())).rayToWad();
+    policy.scr = payout.wadMul(riskModule.scrPercentage().rayToWad()) - policy.purePremium;
+    require(policy.scr != 0, "SCR can't be zero");
+    policy.start = uint40(block.timestamp);
+    policy.expiration = expiration;
+    policy.premiumForLps = policy.scr.wadMul(
+      (
+        (riskModule.scrInterestRate() * (policy.expiration - policy.start)).rayDiv(
+          SECONDS_IN_YEAR_RAY
+        )
+      ).rayToWad()
+    );
+    policy.premiumForEnsuro = (policy.purePremium + policy.premiumForLps).wadMul(
+      riskModule.ensuroFee().rayToWad()
+    );
+    require(
+      policy.purePremium + policy.premiumForEnsuro + policy.premiumForLps <= premium,
+      "Premium less than minimum"
+    );
+    policy.premiumForRm =
+      premium -
+      policy.purePremium -
+      policy.premiumForLps -
+      policy.premiumForEnsuro;
+    return policy;
+  }
+
+  function interestRate(PolicyData memory policy) internal pure returns (uint256) {
+    return
+      policy
+        .premiumForLps
+        .wadMul(SECONDS_IN_YEAR)
+        .wadDiv((policy.expiration - policy.start) * policy.scr)
+        .wadToRay();
+  }
+
+  function accruedInterest(PolicyData memory policy) internal view returns (uint256) {
+    uint256 secs = block.timestamp - policy.start;
+    return
+      policy
+        .scr
+        .wadToRay()
+        .rayMul(secs * interestRate(policy))
+        .rayDiv(SECONDS_IN_YEAR_RAY)
+        .rayToWad();
+  }
+
+  function hash(PolicyData memory policy) internal pure returns (bytes32) {
+    return keccak256(abi.encode(policy));
+  }
+}

package/contracts/PolicyNFT.sol

@@ -0,0 +1,96 @@
+// 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 {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IPolicyNFT} from "../interfaces/IPolicyNFT.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 PolicyNFT is UUPSUpgradeable, ERC721Upgradeable, PausableUpgradeable, IPolicyNFT {
+  bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+  bytes32 public constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
+
+  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_;
+  }
+
+  // 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 policyPool() external view returns (IPolicyPool) {
+    return _policyPool;
+  }
+
+  function safeMint(address to, uint256 policyId) external override onlyPolicyPool whenNotPaused {
+    _safeMint(to, policyId, "");
+  }
+
+  function _beforeTokenTransfer(
+    address from,
+    address to,
+    uint256 tokenId
+  ) internal override whenNotPaused {
+    super._beforeTokenTransfer(from, to, tokenId);
+  }
+}