@ensuro/core 1.2.7 → 2.0.0-beta3

package/contracts/PolicyPool.sol

@@ -5,21 +5,18 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 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";
+import {IPolicyPoolConfig} from "./interfaces/IPolicyPoolConfig.sol";
 import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
 import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
-import {IRiskModule} from "../interfaces/IRiskModule.sol";
-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 {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IRiskModule} from "./interfaces/IRiskModule.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 {Policy} from "./Policy.sol";
 import {WadRayMath} from "./WadRayMath.sol";
-import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
-import {DataTypes} from "./DataTypes.sol";
 
 /**
  * @title Ensuro PolicyPool contract
@@ -32,29 +29,17 @@ import {DataTypes} from "./DataTypes.sol";
  * @custom:security-contact security@ensuro.co
  * @author Ensuro
  */
-// #invariant_disabled {:msg "Borrow up to activePurePremiums"} _borrowedActivePP <= _activePurePremiums;
-// #invariant_disabled {:msg "Can't borrow if not exhausted before won"} (_borrowedActivePP > 0) ==> _wonPurePremiums == 0;
 contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
   using EnumerableSet for EnumerableSet.AddressSet;
   using WadRayMath for uint256;
   using Policy for Policy.PolicyData;
-  using DataTypes for DataTypes.ETokenToWadMap;
-  using DataTypes for DataTypes.ETokenStatusMap;
   using SafeERC20 for IERC20Metadata;
 
-  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-  // solhint-disable-next-line var-name-mixedcase
-  uint256 public immutable NEGLIGIBLE_AMOUNT; // init as 10**(decimals-3) == 0.001 USD
-
-  bytes32 public constant WITHDRAW_WON_PREMIUMS_ROLE = keccak256("WITHDRAW_WON_PREMIUMS_ROLE");
-
   bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
   bytes32 public constant LEVEL1_ROLE = keccak256("LEVEL1_ROLE");
   bytes32 public constant LEVEL2_ROLE = keccak256("LEVEL2_ROLE");
   bytes32 public constant LEVEL3_ROLE = keccak256("LEVEL3_ROLE");
 
-  uint256 public constant MAX_ETOKENS = 10;
-
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   IPolicyPoolConfig internal immutable _config;
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
@@ -62,34 +47,49 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   IPolicyNFT internal immutable _policyNFT;
 
-  DataTypes.ETokenStatusMap internal _eTokens;
+  enum ETokenStatus {
+    inactive, // doesn't exists - All operations rejected
+    active, // deposit / withdraw / lockScr / unlockScr OK
+    deprecated, // withdraw OK, unlockScr OK, deposit rejected, no new policies
+    suspended // all operations temporarily rejected
+  }
 
-  mapping(uint256 => bytes32) internal _policies;
-  mapping(uint256 => DataTypes.ETokenToWadMap) internal _policiesFunds;
+  /**
+   * @dev Mapping of installed eTokens (see {EToken}) in the PolicyPool. For each one it keep an state
+   * {ETokenStatus}.
+   */
+  mapping(IEToken => ETokenStatus) private _eTokens;
 
-  uint256 internal _activePurePremiums; // sum of pure-premiums of active policies - In Wad
-  uint256 internal _borrowedActivePP; // amount borrowed from active pure premiums to pay defaulted policies
-  uint256 internal _wonPurePremiums; // amount of pure premiums won from non-defaulted policies
+  /**
+   * @dev Mapping that stores the active policies (the policyId is the key). It just saves the hash of the policies,
+   * the full {Policy-PolicyData} struct has to be sent for each operation (hash is used to verify).
+   */
+  mapping(uint256 => bytes32) internal _policies;
 
+  /**
+   * @dev Event emitted every time a new policy is added to the pool. Contains all the data about the policy that is
+   * later required for doing operations with the policy like resolution or expiration.
+   */
   event NewPolicy(IRiskModule indexed riskModule, Policy.PolicyData policy);
-  event PolicyRebalanced(IRiskModule indexed riskModule, uint256 indexed policyId);
-  event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
 
-  event ETokenStatusChanged(IEToken indexed eToken, DataTypes.ETokenStatus newStatus);
+  /**
+   * @dev Event emitted every time a policy is removed from the pool. If the policy expired, the `payout` is 0,
+   * otherwise is the amount transferred to the policyholder.
+   */
+  event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
 
-  /*
-   * Premiums can come in (for free, without liability) with receiveGrant.
-   * And can come out (withdrawed to treasury) with withdrawWonPremiums
+  /**
+   * @dev Event emitted when a new eToken is added to the pool or the status changes. See {ETokenStatus}.
    */
-  event WonPremiumsInOut(bool moneyIn, uint256 value);
+  event ETokenStatusChanged(IEToken indexed eToken, ETokenStatus newStatus);
 
-  modifier onlyAssetManager() {
-    require(
-      msg.sender == address(_config.assetManager()),
-      "Only assetManager can call this function"
-    );
-    _;
-  }
+  /**
+   * @dev Event emitted when a new PremiumsAccount is added to the pool or the status changes. TODO
+   */
+  event PremiumsAccountStatusChanged(
+    IPremiumsAccount indexed premiumsAccount,
+    ETokenStatus newStatus
+  );
 
   modifier onlyRole(bytes32 role) {
     _config.checkRole(role, msg.sender);
@@ -110,7 +110,6 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     _config = config_;
     _policyNFT = policyNFT_;
     _currency = currency_;
-    NEGLIGIBLE_AMOUNT = 10**(currency_.decimals() - 3);
   }
 
   function initialize() public initializer {
@@ -122,16 +121,7 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
   // solhint-disable-next-line func-name-mixedcase
   function __PolicyPool_init_unchained() internal initializer {
     _config.connect();
-    require(
-      _config.assetManager() == IAssetManager(address(0)),
-      "AssetManager can't be set before PolicyPool initialization"
-    );
     _policyNFT.connect();
-    /*
-    _activePurePremiums = 0;
-    _borrowedActivePP = 0;
-    _wonPurePremiums = 0;
-    */
   }
 
   // solhint-disable-next-line no-empty-blocks
@@ -157,77 +147,69 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     return address(_policyNFT);
   }
 
-  function purePremiums() public view returns (uint256) {
-    return _activePurePremiums + _wonPurePremiums - _borrowedActivePP;
-  }
-
-  function activePurePremiums() external view returns (uint256) {
-    return _activePurePremiums;
-  }
-
-  function wonPurePremiums() external view returns (uint256) {
-    return _wonPurePremiums;
-  }
-
-  function borrowedActivePP() external view returns (uint256) {
-    return _borrowedActivePP;
-  }
-
-  // #if_succeeds_disabled {:msg "eToken added as active"} _eTokens.get(eToken) == DataTypes.ETokenStatus.active;
   function addEToken(IEToken eToken) external onlyRole(LEVEL1_ROLE) {
-    require(_eTokens.length() < MAX_ETOKENS, "Maximum number of ETokens reached");
-    require(!_eTokens.contains(eToken), "eToken already in the pool");
+    ETokenStatus status = _eTokens[eToken];
+    require(status == ETokenStatus.inactive, "eToken already in the pool");
     require(address(eToken) != address(0), "eToken can't be zero");
     require(
       IPolicyPoolComponent(address(eToken)).policyPool() == this,
       "EToken not linked to this pool"
     );
 
-    _eTokens.set(eToken, DataTypes.ETokenStatus.active);
-    emit ETokenStatusChanged(eToken, DataTypes.ETokenStatus.active);
+    _eTokens[eToken] = ETokenStatus.active;
+    emit ETokenStatusChanged(eToken, ETokenStatus.active);
   }
 
   function removeEToken(IEToken eToken) external onlyRole(LEVEL3_ROLE) {
-    require(_eTokens.get(eToken) == DataTypes.ETokenStatus.deprecated, "EToken not deprecated");
+    ETokenStatus status = _eTokens[eToken];
+    require(status == ETokenStatus.deprecated, "EToken not deprecated");
     require(eToken.totalSupply() == 0, "EToken has liquidity, can't be removed");
-    emit ETokenStatusChanged(eToken, DataTypes.ETokenStatus.inactive);
+    delete _eTokens[eToken];
+    emit ETokenStatusChanged(eToken, ETokenStatus.inactive);
   }
 
-  function changeETokenStatus(IEToken eToken, DataTypes.ETokenStatus newStatus)
+  function changeETokenStatus(IEToken eToken, ETokenStatus newStatus)
     external
     onlyRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
   {
-    require(_eTokens.contains(eToken), "Risk Module not found");
+    ETokenStatus status = _eTokens[eToken];
+    require(status != ETokenStatus.inactive, "EToken not found");
     require(
-      newStatus != DataTypes.ETokenStatus.suspended || _config.hasRole(GUARDIAN_ROLE, msg.sender),
+      newStatus != ETokenStatus.suspended || _config.hasRole(GUARDIAN_ROLE, msg.sender),
       "Only GUARDIAN can suspend eTokens"
     );
-    _eTokens.set(eToken, newStatus);
+    _eTokens[eToken] = newStatus;
     emit ETokenStatusChanged(eToken, newStatus);
   }
 
-  function getETokenStatus(IEToken eToken) external view returns (DataTypes.ETokenStatus) {
-    return _eTokens.get(eToken);
+  function getETokenStatus(IEToken eToken) external view returns (ETokenStatus) {
+    return _eTokens[eToken];
   }
 
-  function setAssetManager(IAssetManager newAssetManager) external override {
-    require(msg.sender == address(_config), "Only the PolicyPoolConfig can change assetManager");
-    if (address(_config.assetManager()) != address(0)) {
-      _config.assetManager().deinvestAll(); // deInvest all assets
-      _currency.approve(address(_config.assetManager()), 0); // revoke currency management approval
+  function addPremiumsAccount(IPremiumsAccount pa) external onlyRole(LEVEL1_ROLE) {
+    // TODO: limit in # of PremiumsAccount?
+    // TODO: keep PremiumsAccount status?
+    require(address(pa) != address(0), "PremiumsAccount can't be zero");
+    require(
+      IPolicyPoolComponent(address(pa)).policyPool() == this,
+      "PremiumsAccount not linked to this pool"
+    );
+    IEToken etk = pa.juniorEtk();
+    if (address(etk) != address(0)) {
+      etk.addBorrower(address(pa));
     }
-    if (address(newAssetManager) != address(0)) {
-      _currency.approve(address(newAssetManager), type(uint256).max);
+    etk = pa.seniorEtk();
+    if (address(etk) != address(0)) {
+      etk.addBorrower(address(pa));
     }
+    emit PremiumsAccountStatusChanged(pa, ETokenStatus.active);
+    // TODO: functions for deactivating premiumsAccount (and remove them as borrower)
   }
 
-  /// #if_succeeds
-  ///    {:msg "must take balance from sender"}
-  ///    _currency.balanceOf(msg.sender) == old(_currency.balanceOf(msg.sender) - amount);
   function deposit(IEToken eToken, uint256 amount) external override whenNotPaused {
-    (bool found, DataTypes.ETokenStatus etkStatus) = _eTokens.tryGet(eToken);
-    require(found && etkStatus == DataTypes.ETokenStatus.active, "eToken is not active");
-    _currency.safeTransferFrom(msg.sender, address(this), amount);
+    ETokenStatus etkStatus = _eTokens[eToken];
+    require(etkStatus == ETokenStatus.active, "eToken is not active");
+    _currency.safeTransferFrom(msg.sender, address(eToken), amount);
     eToken.deposit(msg.sender, amount);
   }
 
@@ -237,19 +219,13 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     whenNotPaused
     returns (uint256)
   {
-    (bool found, DataTypes.ETokenStatus etkStatus) = _eTokens.tryGet(eToken);
+    ETokenStatus etkStatus = _eTokens[eToken];
     require(
-      found &&
-        (
-          (etkStatus == DataTypes.ETokenStatus.active ||
-            etkStatus == DataTypes.ETokenStatus.deprecated)
-        ),
+      etkStatus == ETokenStatus.active || etkStatus == ETokenStatus.deprecated,
       "eToken not found or withdraws not allowed"
     );
     address provider = msg.sender;
-    uint256 withdrawed = eToken.withdraw(provider, amount);
-    if (withdrawed > 0) _transferTo(provider, withdrawed);
-    return withdrawed;
+    return eToken.withdraw(provider, amount);
   }
 
   function newPolicy(
@@ -262,148 +238,34 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     _config.checkAcceptsNewPolicy(rm);
     policy.id = (uint256(uint160(address(rm))) << 96) + internalId;
     _policies[policy.id] = policy.hash();
-    _activePurePremiums += policy.purePremium;
-    _lockScr(policy);
+    IPremiumsAccount pa = rm.premiumsAccount();
+    pa.policyCreated(policy);
     _policyNFT.safeMint(customer, policy.id);
-    _currency.safeTransferFrom(customer, address(this), policy.purePremium + policy.premiumForLps);
-    _currency.safeTransferFrom(customer, _config.treasury(), policy.premiumForEnsuro);
-    if (policy.premiumForRm > 0 && customer != rm.wallet())
-      _currency.safeTransferFrom(customer, rm.wallet(), policy.premiumForRm);
-    emit NewPolicy(rm, policy);
-    return policy.id;
-  }
 
-  function _lockScr(Policy.PolicyData memory policy) internal {
-    uint256 ocean = 0;
-    DataTypes.ETokenToWadMap storage policyFunds = _policiesFunds[policy.id];
-
-    // Initially I iterate over all eTokens and accumulate ocean of eligible ones
-    // saves the ocean in policyFunds, later will _distributeScr
-    for (uint256 i = 0; i < _eTokens.length(); i++) {
-      (IEToken etk, DataTypes.ETokenStatus etkStatus) = _eTokens.at(i);
-      if (etkStatus != DataTypes.ETokenStatus.active) continue;
-      if (!etk.accepts(address(policy.riskModule), policy.expiration)) continue;
-      uint256 etkOcean = etk.oceanForNewScr();
-      if (etkOcean == 0) continue;
-      ocean += etkOcean;
-      policyFunds.set(etk, etkOcean);
-    }
-    _distributeScr(policy.scr, policy.interestRate(), ocean, policyFunds);
-  }
+    // Distribute the premium
+    _currency.safeTransferFrom(customer, address(pa), policy.purePremium);
+    if (policy.srCoc > 0)
+      _currency.safeTransferFrom(customer, address(pa.seniorEtk()), policy.srCoc);
+    if (policy.jrCoc > 0)
+      _currency.safeTransferFrom(customer, address(pa.juniorEtk()), policy.jrCoc);
+    _currency.safeTransferFrom(customer, _config.treasury(), policy.ensuroCommission);
+    if (policy.partnerCommission > 0 && customer != rm.wallet())
+      _currency.safeTransferFrom(customer, rm.wallet(), policy.partnerCommission);
+    // TODO: this code does up to 5 ERC20 transfers. How we can avoid this? Delayed transfers?
 
-  /**
-   * @dev Distributes SCR amount in policyFunds according to ocean per token
-   * @param scr  SCR to distribute
-   * @param ocean  Total ocean available in the ETokens for this SCR
-   * @param policyFunds  Input: loaded with ocean available for this SCR (sum=ocean)
-                         Ouput: loaded with locked SRC (sum=scr)
-   */
-  function _distributeScr(
-    uint256 scr,
-    uint256 interestRate,
-    uint256 ocean,
-    DataTypes.ETokenToWadMap storage policyFunds
-  ) internal {
-    require(ocean >= scr, "Not enought ocean to cover the policy");
-    uint256 scrNotLocked = scr;
-
-    for (uint256 i = 0; i < policyFunds.length(); i++) {
-      uint256 etkScr;
-      (IEToken etk, uint256 etkOcean) = policyFunds.at(i);
-      if (i < policyFunds.length() - 1) etkScr = scr.wadMul(etkOcean).wadDiv(ocean);
-      else etkScr = scrNotLocked;
-      etk.lockScr(interestRate, etkScr);
-      policyFunds.set(etk, etkScr);
-      scrNotLocked -= etkScr;
-    }
+    emit NewPolicy(rm, policy);
+    return policy.id;
   }
 
   function _balance() internal view returns (uint256) {
     return _currency.balanceOf(address(this));
   }
 
-  function _transferTo(address destination, uint256 amount) internal {
-    if (amount == 0) return;
-    if (_config.assetManager() != IAssetManager(address(0)) && _balance() < amount) {
-      _config.assetManager().refillWallet(amount);
-    }
-    // Calculate again the balance and check if enought, if not call unsolvency_hook
-    if (_config.insolvencyHook() != IInsolvencyHook(address(0)) && _balance() < amount) {
-      _config.insolvencyHook().outOfCash(amount - _balance());
-    }
-    _currency.safeTransfer(destination, amount);
-  }
-
-  function _payFromPool(uint256 toPay) internal returns (uint256) {
-    // 1. take from won_pure_premiums
-    if (toPay <= _wonPurePremiums) {
-      _wonPurePremiums -= toPay;
-      return 0;
-    }
-    if (_wonPurePremiums > 0) {
-      toPay -= _wonPurePremiums;
-      _wonPurePremiums = 0;
-    }
-    // 2. borrow from active pure premiums
-    if (_activePurePremiums > _borrowedActivePP) {
-      if (toPay <= (_activePurePremiums - _borrowedActivePP)) {
-        _borrowedActivePP += toPay;
-        return 0;
-      } else {
-        toPay -= _activePurePremiums - _borrowedActivePP;
-        _borrowedActivePP = _activePurePremiums;
-      }
-    }
-    return toPay;
-  }
-
-  function _storePurePremiumWon(uint256 purePremiumWon) internal {
-    if (purePremiumWon == 0) return;
-    if (_borrowedActivePP >= purePremiumWon) {
-      _borrowedActivePP -= purePremiumWon;
-    } else {
-      if (_borrowedActivePP > 0) {
-        purePremiumWon -= _borrowedActivePP;
-        _borrowedActivePP = 0;
-      }
-      _wonPurePremiums += purePremiumWon;
-    }
-  }
-
-  function _processResolution(
-    Policy.PolicyData memory policy,
-    bool customerWon,
-    uint256 payout
-  ) internal returns (uint256, uint256) {
-    uint256 borrowFromScr; // = 0
-    uint256 purePremiumWon; // = 0
-    uint256 aux;
-
-    if (customerWon) {
-      _transferTo(_policyNFT.ownerOf(policy.id), payout);
-      if (policy.purePremium > payout) {
-        purePremiumWon = policy.purePremium - payout;
-      } else {
-        borrowFromScr = _payFromPool(payout - policy.purePremium);
-      }
-    } else {
-      // Pay RM and Ensuro
-      purePremiumWon = policy.purePremium;
-      // cover first _borrowedActivePP
-      if (_borrowedActivePP > _activePurePremiums) {
-        aux = Math.min(_borrowedActivePP - _activePurePremiums, purePremiumWon);
-        _borrowedActivePP -= aux;
-        purePremiumWon -= aux;
-      }
-    }
-    return (borrowFromScr, purePremiumWon);
-  }
-
   function _validatePolicy(Policy.PolicyData memory policy) internal view {
     require(policy.id != 0 && policy.hash() == _policies[policy.id], "Policy not found");
   }
 
-  function expirePolicy(Policy.PolicyData calldata policy) external whenNotPaused {
+  function expirePolicy(Policy.PolicyData calldata policy) external override whenNotPaused {
     require(policy.expiration <= block.timestamp, "Policy not expired yet");
     return _resolvePolicy(policy, 0, true);
   }
@@ -424,6 +286,14 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     return _resolvePolicy(policy, customerWon ? policy.payout : 0, false);
   }
 
+  /**
+   * @dev Internal function that handles the different alternative resolutions for a policy, with or without payout and
+   * expiration.
+   *
+   * @param policy A policy created with {Policy-initialize}
+   * @param payout The amount to paid to the policyholder
+   * @param expired True for expiration resolution (`payout` must be 0)
+   */
   function _resolvePolicy(
     Policy.PolicyData memory policy,
     uint256 payout,
@@ -438,33 +308,17 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
 
     bool customerWon = payout > 0;
 
-    _activePurePremiums -= policy.purePremium;
-
-    (uint256 borrowFromScr, uint256 purePremiumWon) = _processResolution(
-      policy,
-      customerWon,
-      payout
-    );
-
     if (customerWon) {
-      uint256 borrowFromScrLeft;
-      borrowFromScrLeft = _updatePolicyFundsCustWon(policy, borrowFromScr);
-      if (borrowFromScrLeft > NEGLIGIBLE_AMOUNT)
-        borrowFromScrLeft = _takeLoanFromAnyEtk(borrowFromScrLeft);
-      require(
-        borrowFromScrLeft <= NEGLIGIBLE_AMOUNT,
-        "Don't know where to take the rest of the money"
-      );
+      address policyOwner = _policyNFT.ownerOf(policy.id);
+      rm.premiumsAccount().policyResolvedWithPayout(policyOwner, policy, payout);
     } else {
-      purePremiumWon = _updatePolicyFundsCustLost(policy, purePremiumWon);
+      rm.premiumsAccount().policyExpired(policy);
     }
 
-    _storePurePremiumWon(purePremiumWon); // it's possible in some cases purePremiumWon > 0 && customerWon
-    rm.releaseScr(policy.scr);
+    rm.releaseExposure(policy.payout);
 
     emit PolicyResolved(policy.riskModule, policy.id, payout);
     delete _policies[policy.id];
-    delete _policiesFunds[policy.id];
     if (payout > 0) {
       _notifyPayout(policy.id, payout);
     } else {
@@ -472,6 +326,10 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     }
   }
 
+  /**
+   * @dev Notifies the payout with a callback if the policyholder is a contract. Only reverts if the policyholder
+   * contract explicitly reverts. Doesn't reverts is the callback is not implemented.
+   */
   function _notifyPayout(uint256 policyId, uint256 payout) internal {
     address customer = _policyNFT.ownerOf(policyId);
     if (!AddressUpgradeable.isContract(customer)) return;
@@ -494,6 +352,9 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
     }
   }
 
+  /**
+   * @dev Notifies the expiration with a callback if the policyholder is a contract. Never reverts.
+   */
   function _notifyExpiration(uint256 policyId) internal {
     address customer = _policyNFT.ownerOf(policyId);
     if (!AddressUpgradeable.isContract(customer)) return;
@@ -505,218 +366,4 @@ contract PolicyPool is IPolicyPool, PausableUpgradeable, UUPSUpgradeable {
       return;
     }
   }
-
-  function _interestAdjustment(Policy.PolicyData memory policy)
-    internal
-    view
-    returns (bool, uint256)
-  {
-    // Calculate interest accrual adjustment
-    uint256 aux = policy.accruedInterest();
-    if (policy.premiumForLps >= aux) return (true, policy.premiumForLps - aux);
-    else return (false, aux - policy.premiumForLps);
-  }
-
-  function _updatePolicyFundsCustWon(Policy.PolicyData memory policy, uint256 borrowFromScr)
-    internal
-    returns (uint256)
-  {
-    uint256 borrowFromScrLeft = 0;
-    uint256 interestRate = policy.interestRate();
-    (bool positive, uint256 adjustment) = _interestAdjustment(policy);
-
-    // Iterate policyFunds - unlockScr / adjust / take loan
-    DataTypes.ETokenToWadMap storage policyFunds = _policiesFunds[policy.id];
-    for (uint256 i = 0; i < policyFunds.length(); i++) {
-      (IEToken etk, uint256 etkScr) = policyFunds.at(i);
-      etk.unlockScr(interestRate, etkScr);
-      etkScr = etkScr.wadDiv(policy.scr);
-      // etkScr now represents the share of SCR that's covered by this etk (variable reuse)
-      etk.discreteEarning(adjustment.wadMul(etkScr), positive);
-      if (borrowFromScr > 0) {
-        uint256 aux;
-        aux = borrowFromScr.wadMul(etkScr);
-        borrowFromScrLeft += aux - etk.lendToPool(aux, true);
-      }
-    }
-    return borrowFromScrLeft;
-  }
-
-  // Almost duplicated code from _updatePolicyFundsCustWon but separated to avoid stack depth error
-  function _updatePolicyFundsCustLost(Policy.PolicyData memory policy, uint256 purePremiumWon)
-    internal
-    returns (uint256)
-  {
-    uint256 interestRate = policy.interestRate();
-    (bool positive, uint256 adjustment) = _interestAdjustment(policy);
-
-    // Iterate policyFunds - unlockScr / adjust / repay loan
-    DataTypes.ETokenToWadMap storage policyFunds = _policiesFunds[policy.id];
-    for (uint256 i = 0; i < policyFunds.length(); i++) {
-      (IEToken etk, uint256 etkScr) = policyFunds.at(i);
-      etk.unlockScr(interestRate, etkScr);
-      etkScr = etkScr.wadDiv(policy.scr);
-      // etkScr now represents the share of SCR that's covered by this etk (variable reuse)
-      etk.discreteEarning(adjustment.wadMul(etkScr), positive);
-      if (purePremiumWon > 0 && etk.getPoolLoan() > 0) {
-        uint256 aux;
-        // if debt with token, repay from purePremium
-        aux = policy.purePremium.wadMul(etkScr);
-        aux = Math.min(purePremiumWon, Math.min(etk.getPoolLoan(), aux));
-        etk.repayPoolLoan(aux);
-        purePremiumWon -= aux;
-      }
-    }
-    return purePremiumWon;
-  }
-
-  /*
-   * Called when the payout to be taken from policyFunds wasn't enought.
-   * Then I take loan from the others tokens
-   */
-  function _takeLoanFromAnyEtk(uint256 loanLeft) internal returns (uint256) {
-    for (uint256 i = 0; i < _eTokens.length(); i++) {
-      (IEToken etk, DataTypes.ETokenStatus etkStatus) = _eTokens.at(i);
-      if (etkStatus != DataTypes.ETokenStatus.active) continue;
-      loanLeft -= etk.lendToPool(loanLeft, false);
-      if (loanLeft <= NEGLIGIBLE_AMOUNT) break;
-    }
-    return loanLeft;
-  }
-
-  /**
-   *
-   * Repays a loan taken with the eToken with the money in the premium pool.
-   * The repayment should happen without calling this method when customer losses and eToken is one of the
-   * policyFunds. But sometimes we need to take loans from tokens not linked to the policy.
-   *
-   * returns The amount repaid
-   *
-   * Requirements:
-   *
-   * - `eToken` must be `active` or `deprecated`
-   */
-  function repayETokenLoan(IEToken eToken) external whenNotPaused returns (uint256) {
-    (bool found, DataTypes.ETokenStatus etkStatus) = _eTokens.tryGet(eToken);
-    require(
-      found &&
-        (etkStatus == DataTypes.ETokenStatus.active ||
-          etkStatus == DataTypes.ETokenStatus.deprecated),
-      "eToken is not active"
-    );
-    uint256 poolLoan = eToken.getPoolLoan();
-    uint256 toPayLater = _payFromPool(poolLoan);
-    eToken.repayPoolLoan(poolLoan - toPayLater);
-    return poolLoan - toPayLater;
-  }
-
-  /**
-   *
-   * Endpoint to receive "free money" and inject that money into the premium pool.
-   *
-   * Can be used for example if the PolicyPool subscribes an excess loss policy with other company.
-   *
-   */
-  function receiveGrant(uint256 amount) external override {
-    _currency.safeTransferFrom(msg.sender, address(this), amount);
-    _storePurePremiumWon(amount);
-    emit WonPremiumsInOut(true, amount);
-  }
-
-  /**
-   *
-   * Withdraws excess premiums to PolicyPool's treasury.
-   * This might be needed in some cases for example if we are deprecating the protocol or the excess premiums
-   * are needed to compensate something. Shouldn't be used. Can be disabled revoking role WITHDRAW_WON_PREMIUMS_ROLE
-   *
-   * returns The amount withdrawed
-   *
-   * Requirements:
-   *
-   * - onlyRole(WITHDRAW_WON_PREMIUMS_ROLE)
-   * - _wonPurePremiums > 0
-   */
-  function withdrawWonPremiums(uint256 amount)
-    external
-    onlyRole(WITHDRAW_WON_PREMIUMS_ROLE)
-    returns (uint256)
-  {
-    if (amount > _wonPurePremiums) amount = _wonPurePremiums;
-    require(amount > 0, "No premiums to withdraw");
-    _wonPurePremiums -= amount;
-    _transferTo(_config.treasury(), amount);
-    emit WonPremiumsInOut(false, amount);
-    return amount;
-  }
-
-  function getInvestable() external view override returns (uint256) {
-    uint256 borrowedFromEtk = 0;
-    for (uint256 i = 0; i < _eTokens.length(); i++) {
-      (
-        IEToken etk, /* DataTypes.ETokenStatus etkStatus */
-
-      ) = _eTokens.at(i);
-      // TODO: define if not active are investable or not
-      borrowedFromEtk += etk.getPoolLoan();
-    }
-    uint256 premiums = purePremiums();
-    if (premiums > borrowedFromEtk) return premiums - borrowedFromEtk;
-    else return 0;
-  }
-
-  function totalETokenSupply() public view override returns (uint256) {
-    uint256 ret = 0;
-    for (uint256 i = 0; i < _eTokens.length(); i++) {
-      (
-        IEToken etk, /* DataTypes.ETokenStatus etkStatus */
-
-      ) = _eTokens.at(i);
-      // TODO: define if not active are investable or not
-      ret += etk.totalSupply();
-    }
-    return ret;
-  }
-
-  function assetEarnings(uint256 amount, bool positive)
-    external
-    override
-    onlyAssetManager
-    whenNotPaused
-  {
-    if (positive) {
-      // earnings
-      _storePurePremiumWon(amount);
-    } else {
-      // losses
-      _payFromPool(amount); // return value should be 0 if not, losses are more than capital available
-    }
-  }
-
-  function getPolicyFundCount(uint256 policyId) external view returns (uint256) {
-    return _policiesFunds[policyId].length();
-  }
-
-  function getPolicyFundAt(uint256 policyId, uint256 index)
-    external
-    view
-    returns (IEToken, uint256)
-  {
-    return _policiesFunds[policyId].at(index);
-  }
-
-  function getPolicyFund(uint256 policyId, IEToken etoken) external view returns (uint256) {
-    (bool success, uint256 amount) = _policiesFunds[policyId].tryGet(etoken);
-    if (success) return amount;
-    else return 0;
-  }
-
-  function getETokenCount() external view override returns (uint256) {
-    return _eTokens.length();
-  }
-
-  function getETokenAt(uint256 index) external view override returns (IEToken) {
-    (IEToken etk, DataTypes.ETokenStatus etkStatus) = _eTokens.at(index);
-    if (etkStatus != DataTypes.ETokenStatus.inactive) return etk;
-    else return IEToken(address(0));
-  }
 }