@ensuro/core 1.2.0 → 1.2.3

package/contracts/PolicyPool.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {AddressUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
@@ -13,6 +14,7 @@ import {IInsolvencyHook} from "../interfaces/IInsolvencyHook.sol";
 import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
 import {IEToken} from "../interfaces/IEToken.sol";
 import {IPolicyNFT} from "../interfaces/IPolicyNFT.sol";
+import {IPolicyHolder} from "../interfaces/IPolicyHolder.sol";
 import {IAssetManager} from "../interfaces/IAssetManager.sol";
 import {Policy} from "./Policy.sol";
 import {WadRayMath} from "./WadRayMath.sol";
@@ -44,7 +46,6 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
   // solhint-disable-next-line var-name-mixedcase
   uint256 public immutable NEGLIGIBLE_AMOUNT; // init as 10**(decimals-3) == 0.001 USD
 
-  bytes32 public constant REBALANCE_ROLE = keccak256("REBALANCE_ROLE");
   bytes32 public constant WITHDRAW_WON_PREMIUMS_ROLE = keccak256("WITHDRAW_WON_PREMIUMS_ROLE");
 
   bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
@@ -464,6 +465,45 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     emit PolicyResolved(policy.riskModule, policy.id, payout);
     delete _policies[policy.id];
     delete _policiesFunds[policy.id];
+    if (payout > 0) {
+      _notifyPayout(policy.id, payout);
+    } else {
+      _notifyExpiration(policy.id);
+    }
+  }
+
+  function _notifyPayout(uint256 policyId, uint256 payout) internal {
+    address customer = _policyNFT.ownerOf(policyId);
+    if (!AddressUpgradeable.isContract(customer)) return;
+    try
+      IPolicyHolder(customer).onPayoutReceived(_msgSender(), address(this), policyId, payout)
+    returns (bytes4 retval) {
+      require(
+        retval == IPolicyHolder.onPayoutReceived.selector,
+        "Invalid return value from Policy Holder"
+      );
+    } catch (bytes memory reason) {
+      if (reason.length == 0) {
+        return; // Not implemented, it's fine
+      } else {
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+          revert(add(32, reason), mload(reason))
+        }
+      }
+    }
+  }
+
+  function _notifyExpiration(uint256 policyId) internal {
+    address customer = _policyNFT.ownerOf(policyId);
+    if (!AddressUpgradeable.isContract(customer)) return;
+    try IPolicyHolder(customer).onPolicyExpired(_msgSender(), address(this), policyId) returns (
+      bytes4
+    ) {
+      return;
+    } catch {
+      return;
+    }
   }
 
   function _interestAdjustment(Policy.PolicyData memory policy)
@@ -609,40 +649,6 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     return amount;
   }
 
-  function rebalancePolicy(Policy.PolicyData calldata policy)
-    external
-    onlyRole(REBALANCE_ROLE)
-    whenNotPaused
-  {
-    _validatePolicy(policy);
-    DataTypes.ETokenToWadMap storage policyFunds = _policiesFunds[policy.id];
-    uint256 ocean = 0;
-
-    // Iterates all the tokens
-    // If locked - unlocks - finally stores the available ocean in policyFunds
-    for (uint256 i = 0; i < _eTokens.length(); i++) {
-      (IEToken etk, DataTypes.ETokenStatus etkStatus) = _eTokens.at(i);
-      uint256 etkOcean = 0;
-      (bool locked, uint256 etkScr) = policyFunds.tryGet(etk);
-      if (locked) {
-        etk.unlockScr(policy.interestRate(), etkScr);
-      }
-      if (
-        etkStatus == DataTypes.ETokenStatus.active &&
-        etk.accepts(address(policy.riskModule), policy.expiration)
-      ) etkOcean = etk.oceanForNewScr();
-      if (etkOcean == 0) {
-        if (locked) policyFunds.remove(etk);
-      } else {
-        policyFunds.set(etk, etkOcean);
-        ocean += etkOcean;
-      }
-    }
-
-    _distributeScr(policy.scr, policy.interestRate(), ocean, policyFunds);
-    emit PolicyRebalanced(policy.riskModule, policy.id);
-  }
-
   function getInvestable() external view override returns (uint256) {
     uint256 borrowedFromEtk = 0;
     for (uint256 i = 0; i < _eTokens.length(); i++) {

package/contracts/PolicyPoolComponent.sol

@@ -134,11 +134,15 @@ abstract contract PolicyPoolComponent is
     }
   }
 
+  // solhint-disable-next-line no-empty-blocks
+  function _validateParameters() internal view virtual {} // Must be reimplemented with specific validations
+
   function _parameterChanged(
     IPolicyPoolConfig.GovernanceActions action,
     uint256 value,
     bool tweak
   ) internal {
+    _validateParameters();
     if (tweak) _registerTweak(action);
     emit GovernanceAction(action, value);
   }

package/contracts/PolicyPoolConfig.sol

@@ -10,6 +10,7 @@ import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
 import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IRiskModule} from "../interfaces/IRiskModule.sol";
 import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
+import {IExchange} from "../interfaces/IExchange.sol";
 import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
 import {WadRayMath} from "./WadRayMath.sol";
 
@@ -40,6 +41,7 @@ contract PolicyPoolConfig is
   IInsolvencyHook internal _insolvencyHook; // Contract that handles insolvency situations
   IPolicyPool internal _policyPool;
   ILPWhitelist internal _lpWhitelist; // Contract that handles whitelisting of Liquidity Providers
+  IExchange internal _exchange; // Contract that handles exchange operations between assets
 
   mapping(IRiskModule => RiskModuleStatus) private _riskModules;
 
@@ -168,6 +170,20 @@ contract PolicyPoolConfig is
     return _lpWhitelist;
   }
 
+  function setExchange(IExchange exchange_) external onlyRole2(GUARDIAN_ROLE, LEVEL1_ROLE) {
+    require(
+      address(exchange_) == address(0) ||
+        IPolicyPoolComponent(address(exchange_)).policyPool() == _policyPool,
+      "Component not linked to this PolicyPool"
+    );
+    _exchange = exchange_;
+    emit ComponentChanged(GovernanceActions.setExchange, address(_exchange));
+  }
+
+  function exchange() external view override returns (IExchange) {
+    return _exchange;
+  }
+
   function addRiskModule(IRiskModule riskModule) external onlyRole2(LEVEL1_ROLE, LEVEL2_ROLE) {
     require(
       _riskModules[riskModule] == RiskModuleStatus.inactive,

package/contracts/RiskModule.sol

@@ -37,11 +37,6 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
 
   address internal _wallet; // Address of the RiskModule provider
 
-  modifier validateParamsAfterChange() {
-    _;
-    _validateParameters();
-  }
-
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
   constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
@@ -104,7 +99,7 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   }
 
   // runs validation on RiskModule parameters
-  function _validateParameters() internal view {
+  function _validateParameters() internal view override {
     require(
       _scrPercentage <= WadRayMath.RAY && _scrPercentage > 0,
       "Validation: scrPercentage must be <=1"
@@ -159,7 +154,6 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   function setScrPercentage(uint256 newScrPercentage)
     external
     onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -174,11 +168,7 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     );
   }
 
-  function setMoc(uint256 newMoc)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
+  function setMoc(uint256 newMoc) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(!tweak || _isTweakRay(_moc, newMoc, 1e26), "Tweak exceeded: moc tweaks only up to 10%");
     _moc = newMoc;
@@ -188,7 +178,6 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   function setScrInterestRate(uint256 newScrInterestRate)
     external
     onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -203,11 +192,7 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     );
   }
 
-  function setEnsuroFee(uint256 newEnsuroFee)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
-  {
+  function setEnsuroFee(uint256 newEnsuroFee) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
       !tweak || _isTweakRay(_ensuroFee, newEnsuroFee, 3e26),
@@ -220,7 +205,6 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   function setMaxScrPerPolicy(uint256 newMaxScrPerPolicy)
     external
     onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
@@ -238,7 +222,6 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   function setScrLimit(uint256 newScrLimit)
     external
     onlyPoolRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
-    validateParamsAfterChange
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
     require(
@@ -256,11 +239,7 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     _parameterChanged(IPolicyPoolConfig.GovernanceActions.setScrLimit, newScrLimit, tweak);
   }
 
-  function setWallet(address wallet_)
-    external
-    onlyRole(RM_PROVIDER_ROLE)
-    validateParamsAfterChange
-  {
+  function setWallet(address wallet_) external onlyRole(RM_PROVIDER_ROLE) {
     _wallet = wallet_;
     _parameterChanged(
       IPolicyPoolConfig.GovernanceActions.setWallet,
@@ -273,7 +252,7 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     uint256 payout,
     uint256 lossProb,
     uint40 expiration
-  ) external view returns (uint256) {
+  ) public view returns (uint256) {
     uint256 purePremium = payout.wadToRay().rayMul(lossProb.rayMul(moc())).rayToWad();
     uint256 scr = payout.wadMul(scrPercentage().rayToWad()) - purePremium;
     uint256 interestRate = (

package/contracts/extras/IPriceRiskModule.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IRiskModule} from "../../interfaces/IRiskModule.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+/**
+ * @title IPriceRiskModule interface
+ * @dev Interface for price risk module
+ * @author Ensuro
+ */
+interface IPriceRiskModule is IRiskModule {
+  /**
+   * @dev Returns the premium and lossProb of the policy
+   * @param triggerPrice Price of the asset_ that will trigger the policy (expressed in _currency)
+   * @param lower If true -> triggers if the price is lower, If false -> triggers if the price is higher
+   * @param payout Expressed in policyPool.currency()
+   * @param expiration Expiration of the policy
+   * @return premium Premium that needs to be paid
+   * @return lossProb Probability of paying the maximum payout
+   */
+  function pricePolicy(
+    uint256 triggerPrice,
+    bool lower,
+    uint256 payout,
+    uint40 expiration
+  ) external view returns (uint256 premium, uint256 lossProb);
+
+  function newPolicy(
+    uint256 triggerPrice,
+    bool lower,
+    uint256 payout,
+    uint40 expiration
+  ) external returns (uint256);
+
+  function triggerPolicy(uint256 policyId) external;
+
+  function referenceCurrency() external view returns (IERC20Metadata);
+
+  function asset() external view returns (IERC20Metadata);
+}

package/contracts/extras/PriceRiskModule.sol

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IPolicyPool} from "../../interfaces/IPolicyPool.sol";
+import {IPolicyPoolConfig} from "../../interfaces/IPolicyPoolConfig.sol";
+import {RiskModule} from "../RiskModule.sol";
+import {Policy} from "../Policy.sol";
+import {WadRayMath} from "../WadRayMath.sol";
+import {IPriceRiskModule} from "./IPriceRiskModule.sol";
+
+/**
+ * @title PriceRiskModule
+ * @dev Risk Module that triggers the payout if the price of an asset is lower or higher than trigger price
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+contract PriceRiskModule is RiskModule, IPriceRiskModule {
+  using SafeERC20 for IERC20Metadata;
+  using WadRayMath for uint256;
+
+  bytes32 public constant CUSTOMER_ROLE = keccak256("CUSTOMER_ROLE");
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+
+  uint8 public constant PRICE_SLOTS = 30;
+
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  IERC20Metadata internal immutable _asset;
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  IERC20Metadata internal immutable _referenceCurrency;
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  uint256 internal immutable _slotSize;
+
+  struct PolicyData {
+    Policy.PolicyData ensuroPolicy;
+    uint256 triggerPrice;
+    bool lower; // If true -> triggers if the price is lower, If false -> triggers if the price is higher
+  }
+
+  mapping(uint256 => PolicyData) internal _policies;
+
+  // Duration (in hours) of the protection * (1 if lower else -1) => cummulative density function
+  //   [0] = prob of ([0, infinite%)
+  //   [1] = prob of ([1, infinite%)
+  //   ...
+  //   [PRICE_SLOTS - 1] = prob of ([PRICE_SLOTS - 1, -infinite%)
+  mapping(int40 => uint256[PRICE_SLOTS]) internal _cdf;
+
+  uint96 internal _internalId;
+
+  event NewPricePolicy(
+    address indexed customer,
+    uint256 policyId,
+    uint256 triggerPrice,
+    bool lower
+  );
+
+  /**
+   * @dev Constructs the LiquidationProtectionRiskModule
+   * @param policyPool_ The policyPool
+   * @param asset_ Address of the asset which price want to protect
+   * @param referenceCurrency_ Address of the comparison asset (price will be price(asset)/price(currency))
+   * @param slotSize_ Size of each percentage slot in the pdf function (in wad)
+   */
+  /// @custom:oz-upgrades-unsafe-allow constructor
+  constructor(
+    IPolicyPool policyPool_,
+    IERC20Metadata asset_,
+    IERC20Metadata referenceCurrency_,
+    uint256 slotSize_
+  ) RiskModule(policyPool_) {
+    _asset = asset_;
+    _referenceCurrency = referenceCurrency_;
+    _slotSize = slotSize_;
+  }
+
+  /**
+   * @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
+   */
+  function initialize(
+    string memory name_,
+    uint256 scrPercentage_,
+    uint256 ensuroFee_,
+    uint256 scrInterestRate_,
+    uint256 maxScrPerPolicy_,
+    uint256 scrLimit_,
+    address wallet_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      scrPercentage_,
+      ensuroFee_,
+      scrInterestRate_,
+      maxScrPerPolicy_,
+      scrLimit_,
+      wallet_
+    );
+    _internalId = 1;
+  }
+
+  function _getCurrentPrice() internal view returns (uint256) {
+    uint256 ret = policyPool().config().exchange().convert(
+      address(_asset),
+      address(_referenceCurrency),
+      10**_asset.decimals()
+    );
+    require(ret != 0, "Price not available");
+    return ret;
+  }
+
+  /**
+   * @dev Returns the premium and lossProb of the policy
+   * @param triggerPrice Price of the asset_ that will trigger the policy (expressed in _referenceCurrency)
+   * @param lower If true -> triggers if the price is lower, If false -> triggers if the price is higher
+   * @param payout Expressed in policyPool.currency()
+   * @param expiration Expiration of the policy
+   * @return premium Premium that needs to be paid
+   * @return lossProb Probability of paying the maximum payout
+   */
+  function pricePolicy(
+    uint256 triggerPrice,
+    bool lower,
+    uint256 payout,
+    uint40 expiration
+  ) public view override returns (uint256 premium, uint256 lossProb) {
+    uint256 currentPrice = _getCurrentPrice();
+    require(
+      (lower && currentPrice > triggerPrice) || (!lower && currentPrice < triggerPrice),
+      "Price already at trigger value"
+    );
+    lossProb = _computeLossProb(currentPrice, triggerPrice, expiration - uint40(block.timestamp));
+    if (lossProb == 0) return (0, 0);
+    premium = getMinimumPremium(payout, lossProb, expiration); // TODO: extra fee for RiskModule?
+    return (premium, lossProb);
+  }
+
+  function _computeLossProb(
+    uint256 currentPrice,
+    uint256 triggerPrice,
+    uint40 duration
+  ) internal view returns (uint256) {
+    uint256[PRICE_SLOTS] storage pdf = _cdf[
+      int40((duration + 1800) / 3600) * (currentPrice > triggerPrice ? int40(1) : int40(-1))
+    ];
+    uint256 priceJump;
+    uint256 decimalConv = 10**(18 - _referenceCurrency.decimals());
+    // Calculate the jump percentage as integer with simetric rounding
+    if (currentPrice > triggerPrice) {
+      priceJump =
+        WadRayMath.wad() -
+        (triggerPrice * decimalConv).wadDiv(currentPrice * decimalConv);
+    } else {
+      priceJump =
+        (triggerPrice * decimalConv).wadDiv(currentPrice * decimalConv) -
+        WadRayMath.wad();
+    }
+
+    uint8 downPerc = uint8((priceJump + _slotSize / 2) / _slotSize);
+
+    if (downPerc >= PRICE_SLOTS) {
+      return pdf[PRICE_SLOTS - 1];
+    } else {
+      return pdf[downPerc];
+    }
+  }
+
+  function newPolicy(
+    uint256 triggerPrice,
+    bool lower,
+    uint256 payout,
+    uint40 expiration
+  ) external override returns (uint256) {
+    (uint256 premium, uint256 lossProb) = pricePolicy(triggerPrice, lower, payout, expiration);
+    require(premium > 0, "Either duration or percentage jump not supported");
+
+    uint256 policyId = (uint256(uint160(address(this))) << 96) + _internalId;
+    PolicyData storage priceRiskPolicy = _policies[policyId];
+    address customer = _msgSender();
+    priceRiskPolicy.ensuroPolicy = _newPolicy(
+      payout,
+      premium,
+      lossProb,
+      expiration,
+      customer,
+      _internalId
+    );
+    _internalId += 1;
+    priceRiskPolicy.triggerPrice = triggerPrice;
+    priceRiskPolicy.lower = lower;
+    emit NewPricePolicy(customer, policyId, triggerPrice, lower);
+    return policyId;
+  }
+
+  function triggerPolicy(uint256 policyId) external override whenNotPaused {
+    PolicyData storage policy = _policies[policyId];
+    uint256 currentPrice = _getCurrentPrice();
+    require(
+      !policy.lower || currentPrice <= policy.triggerPrice,
+      "Condition not met CurrentPrice > triggerPrice"
+    );
+    require(
+      policy.lower || currentPrice >= policy.triggerPrice,
+      "Condition not met CurrentPrice < triggerPrice"
+    );
+
+    _policyPool.resolvePolicy(policy.ensuroPolicy, policy.ensuroPolicy.payout);
+  }
+
+  /**
+   * @dev Sets the probability distribution for a given duration
+   * @param duration Duration of the policy in hours (simetric rounding) positive if probability of lower price
+   *                 negative if probability of higher price
+   * @param cdf Array where cdf[i] = prob of price lower/higher than i% of current price
+   */
+  function setCDF(int40 duration, uint256[PRICE_SLOTS] calldata cdf)
+    external
+    onlyRole(PRICER_ROLE)
+    whenNotPaused
+  {
+    _cdf[duration] = cdf;
+  }
+
+  function getCDF(int40 duration) external view returns (uint256[PRICE_SLOTS] memory) {
+    return _cdf[duration];
+  }
+
+  function referenceCurrency() external view override returns (IERC20Metadata) {
+    return _referenceCurrency;
+  }
+
+  function asset() external view override returns (IERC20Metadata) {
+    return _asset;
+  }
+}

package/interfaces/IExchange.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title IPriceOracle - Interface for external price oracle to get assets' prices
+ * @author Ensuro
+ */
+interface IPriceOracle {
+  /**
+   * @dev Returns the price of the asset in ETH
+   * @param asset Address of a ERC20 asset
+   * @return Price of the asset in ETH (Wad)
+   */
+  function getAssetPrice(address asset) external view returns (uint256);
+}
+
+/**
+ * @title IExchange - Interface that handles exchange operations between tokens
+ * @author Ensuro
+ */
+interface IExchange {
+  function convert(
+    address assetFrom,
+    address assetTo,
+    uint256 amount
+  ) external view returns (uint256);
+
+  function getAmountIn(
+    address assetIn,
+    address assetOut,
+    uint256 amountOut
+  ) external view returns (uint256);
+
+  function getSwapRouter() external view returns (address);
+
+  function getPriceOracle() external view returns (IPriceOracle);
+
+  function sell(
+    address assetIn,
+    address assetOut,
+    uint256 amountInExact,
+    address outAddr,
+    uint256 deadline
+  ) external view returns (bytes memory);
+
+  function decodeSwapOut(bytes memory responseData) external view returns (uint256);
+}

package/interfaces/IPolicyHolder.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+/**
+ * @title Policy holder interface
+ * @dev Interface for any contract that wants to be a holder of Ensuro Policies and receive the payouts
+ */
+interface IPolicyHolder is IERC721Receiver {
+  /**
+   * @dev Whenever an Policy is expired or resolved with payout = 0, this function is called
+   *
+   * It should 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.
+   * No mather what's the return value or even if this function reverts, this function will not revert the policy
+   * expiration.
+   *
+   * The selector can be obtained in Solidity with `IPolicyPool.onPolicyExpired.selector`.
+   */
+  function onPolicyExpired(
+    address operator,
+    address from,
+    uint256 policyId
+  ) external returns (bytes4);
+
+  /**
+   * @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 returns (bytes4);
+}

package/interfaces/IPolicyPoolConfig.sol

@@ -6,6 +6,7 @@ import {IAssetManager} from "./IAssetManager.sol";
 import {IInsolvencyHook} from "./IInsolvencyHook.sol";
 import {ILPWhitelist} from "./ILPWhitelist.sol";
 import {IRiskModule} from "./IRiskModule.sol";
+import {IExchange} from "./IExchange.sol";
 
 /**
  * @title IPolicyPoolAccess - Interface for the contract that handles roles for the PolicyPool and components
@@ -45,6 +46,7 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
     setMaxSlippage,
     setAcceptAllRMs, // EToken Governance action  - value == boolean
     setAcceptException, // EToken Governance action - value == (!isException << 255)|address
+    setExchange, // Changes exchange helper contract
     last
   }
 
@@ -73,6 +75,8 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
 
   function lpWhitelist() external view returns (ILPWhitelist);
 
+  function exchange() external view returns (IExchange);
+
   function treasury() external view returns (address);
 
   function checkAcceptsNewPolicy(IRiskModule riskModule) external view;

package/package.json

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