@ensuro/core 2.0.0-beta6 → 2.0.0-beta7

package/contracts/PremiumsAccount.sol

@@ -11,6 +11,7 @@ import {Reserve} from "./Reserve.sol";
 import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
 import {Policy} from "./Policy.sol";
 import {IEToken} from "./interfaces/IEToken.sol";
+import {IAssetManager} from "./interfaces/IAssetManager.sol";
 
 /**
  * @title Ensuro Premiums Account
@@ -31,8 +32,14 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
   IEToken internal immutable _seniorEtk;
 
   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
+  int256 internal _surplus;
+
+  struct PackedParams {
+    uint16 deficitRatio;
+    IAssetManager assetManager;
+  }
+
+  PackedParams internal _params;
 
   /*
    * Premiums can come in (for free, without liability) with receiveGrant.
@@ -71,21 +78,45 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
   function __PremiumsAccount_init_unchained() internal initializer {
     /*
     _activePurePremiums = 0;
-    _borrowedActivePP = 0;
-    _wonPurePremiums = 0;
     */
     if (address(_juniorEtk) != address(0))
       currency().approve(address(_juniorEtk), type(uint256).max);
     if (address(_seniorEtk) != address(0))
       currency().approve(address(_seniorEtk), type(uint256).max);
+
+    _params = PackedParams({deficitRatio: 1e4, assetManager: IAssetManager(address(0))});
     _validateParameters();
   }
 
+  function assetManager() public view override returns (IAssetManager) {
+    return _params.assetManager;
+  }
+
+  function _setAssetManager(IAssetManager newAM) internal override {
+    _params.assetManager = newAM;
+  }
+
+  function _assetEarnings(int256 earningsOrLosses) internal override {
+    if (earningsOrLosses > 0) {
+      uint256 earnings = uint256(earningsOrLosses);
+      if (address(_seniorEtk) != address(0)) earnings = _repayLoan(earnings, _seniorEtk);
+      if (address(_juniorEtk) != address(0)) earnings = _repayLoan(earnings, _juniorEtk);
+      _storePurePremiumWon(earnings);
+    } else {
+      _payFromPremiums(uint256(-earningsOrLosses));
+    }
+  }
+
   // solhint-disable-next-line no-empty-blocks
-  function _validateParameters() internal view override {}
+  function _validateParameters() internal view override {
+    require(
+      _params.deficitRatio <= 1e4 && _params.deficitRatio >= 0,
+      "Validation: deficitRatio must be <= 1"
+    );
+  }
 
-  function purePremiums() public view returns (uint256) {
-    return _activePurePremiums + _wonPurePremiums - _borrowedActivePP;
+  function purePremiums() external view override returns (uint256) {
+    return uint256(int256(_activePurePremiums) + _surplus);
   }
 
   function activePurePremiums() external view returns (uint256) {
@@ -93,11 +124,15 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
   }
 
   function wonPurePremiums() external view returns (uint256) {
-    return _wonPurePremiums;
+    return _surplus >= 0 ? uint256(_surplus) : 0;
   }
 
   function borrowedActivePP() external view returns (uint256) {
-    return _borrowedActivePP;
+    return _surplus >= 0 ? 0 : uint256(-_surplus);
+  }
+
+  function surplus() external view returns (int256) {
+    return _surplus;
   }
 
   function seniorEtk() external view override returns (IEToken) {
@@ -108,37 +143,63 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     return _juniorEtk;
   }
 
-  function _payFromPool(uint256 toPay) internal returns (uint256) {
-    // 1. take from won_pure_premiums
-    if (toPay <= _wonPurePremiums) {
-      _wonPurePremiums -= toPay;
-      return 0;
+  function _maxDeficit(uint256 ratio) internal view returns (int256) {
+    return -int256(_activePurePremiums.wadMul(ratio));
+  }
+
+  function deficitRatio() public view returns (uint256) {
+    return uint256(_params.deficitRatio) * 1e14; // 4 -> 18 decimals
+  }
+
+  function setDeficitRatio(uint256 newRatio, bool adjustment)
+    external
+    onlyComponentRole(LEVEL2_ROLE)
+  {
+    require(newRatio <= 1e18 && newRatio >= 0, "Validation: deficitRatio must be <= 1");
+    int256 maxDeficit = _maxDeficit(newRatio);
+    require(adjustment || _surplus >= maxDeficit, "Validation: surplus must be >= maxDeficit");
+    if (_surplus < maxDeficit) {
+      // Do the adjustment
+      uint256 borrow = uint256(-_surplus + maxDeficit);
+      _surplus = maxDeficit;
+      _borrowFromEtk(borrow, address(this), address(_juniorEtk) != address(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;
-      }
+    _params.deficitRatio = uint16(newRatio / 1e14);
+  }
+
+  function _borrowFromEtk(
+    uint256 borrow,
+    address receiver,
+    bool jrEtk
+  ) internal {
+    uint256 left;
+    if (jrEtk) {
+      // Consume Junior Pool until exhausted
+      left = _juniorEtk.internalLoan(borrow, receiver, false);
+    } else {
+      left = borrow;
+    }
+    if (left > NEGLIGIBLE_AMOUNT) {
+      // Consume Senior Pool only up to SCR
+      left = _seniorEtk.internalLoan(left, receiver, true);
+      require(left <= NEGLIGIBLE_AMOUNT, "Don't know where to take the rest of the money");
     }
-    return toPay;
+  }
+
+  function _payFromPremiums(uint256 toPay) internal returns (uint256) {
+    int256 newSurplus = _surplus - int256(toPay);
+    int256 maxDeficit = _maxDeficit(deficitRatio());
+    if (newSurplus >= maxDeficit) {
+      _surplus = newSurplus;
+      return 0;
+    }
+    _surplus = maxDeficit;
+    return uint256(-newSurplus + maxDeficit);
   }
 
   function _storePurePremiumWon(uint256 purePremiumWon) internal {
-    // TODO: merge _wonPurePremiums and _borrowedActivePP into single int256 variable
-    // and this will be just `_wonPurePremiums += purePremiumWon;`
     if (purePremiumWon == 0) return;
-    if (_borrowedActivePP >= purePremiumWon) {
-      _borrowedActivePP -= purePremiumWon;
-    } else {
-      _wonPurePremiums += (purePremiumWon - _borrowedActivePP);
-      _borrowedActivePP = 0;
-    }
+    _surplus += int256(purePremiumWon);
   }
 
   // TODO: restore repayETokenLoan?
@@ -166,24 +227,32 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
    *
    * Requirements:
    *
-   * - onlyPoolRole(WITHDRAW_WON_PREMIUMS_ROLE)
+   * - onlyGlobalOrComponentRole(WITHDRAW_WON_PREMIUMS_ROLE)
    * - _wonPurePremiums > 0
    */
-  function withdrawWonPremiums(uint256 amount)
+  function withdrawWonPremiums(uint256 amount, address destination)
     external
-    onlyPoolRole(WITHDRAW_WON_PREMIUMS_ROLE)
+    onlyGlobalOrComponentRole(WITHDRAW_WON_PREMIUMS_ROLE)
     returns (uint256)
   {
-    if (amount > _wonPurePremiums) amount = _wonPurePremiums;
+    if (_surplus <= 0) {
+      amount = 0;
+    } else {
+      amount = Math.min(amount, uint256(_surplus));
+    }
     require(amount > 0, "No premiums to withdraw");
-    _wonPurePremiums -= amount;
-    _transferTo(_policyPool.treasury(), amount); // TODO: discuss if destination shoud be msg.sender
-    // TODO: see if this will be a component role
+    _surplus -= int256(amount);
+    _transferTo(destination, amount);
     emit WonPremiumsInOut(false, amount);
     return amount;
   }
 
-  function policyCreated(Policy.PolicyData memory policy) external override onlyPolicyPool {
+  function policyCreated(Policy.PolicyData memory policy)
+    external
+    override
+    onlyPolicyPool
+    whenNotPaused
+  {
     _activePurePremiums += policy.purePremium;
     if (policy.jrScr > 0) _juniorEtk.lockScr(policy.jrScr, policy.jrInterestRate());
     if (policy.srScr > 0) _seniorEtk.lockScr(policy.srScr, policy.srInterestRate());
@@ -193,7 +262,7 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     address policyHolder,
     Policy.PolicyData memory policy,
     uint256 payout
-  ) external override onlyPolicyPool {
+  ) external override onlyPolicyPool whenNotPaused {
     _activePurePremiums -= policy.purePremium;
     if (policy.purePremium >= payout) {
       uint256 purePremiumWon = policy.purePremium - payout;
@@ -205,21 +274,10 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
       _unlockScr(policy);
       _transferTo(policyHolder, payout);
     } else {
-      uint256 borrowFromScr = _payFromPool(payout - policy.purePremium);
+      uint256 borrowFromScr = _payFromPremiums(payout - policy.purePremium);
       _unlockScr(policy);
       if (borrowFromScr > 0) {
-        uint256 left;
-        if (policy.jrScr > 0) {
-          // Consume Junior Pool until exhausted
-          left = _juniorEtk.internalLoan(borrowFromScr, policyHolder, false);
-        } else {
-          left = borrowFromScr;
-        }
-        if (left > NEGLIGIBLE_AMOUNT) {
-          // Consume Senior Pool only up to SCR
-          left = _seniorEtk.internalLoan(left, policyHolder, true);
-          require(left <= NEGLIGIBLE_AMOUNT, "Don't know where to take the rest of the money");
-        }
+        _borrowFromEtk(borrowFromScr, policyHolder, policy.jrScr > 0);
       }
       _transferTo(policyHolder, payout - borrowFromScr);
     }
@@ -252,16 +310,21 @@ contract PremiumsAccount is IPremiumsAccount, Reserve {
     return purePremiumWon - repayAmount;
   }
 
-  function policyExpired(Policy.PolicyData memory policy) external override onlyPolicyPool {
-    uint256 aux;
+  function policyExpired(Policy.PolicyData memory policy)
+    external
+    override
+    onlyPolicyPool
+    whenNotPaused
+  {
     uint256 purePremiumWon = policy.purePremium;
     _activePurePremiums -= purePremiumWon;
 
     // If negative _activePurePremiums, repay this first (shouldn't happen)
-    if (_borrowedActivePP > _activePurePremiums) {
-      aux = Math.min(_borrowedActivePP - _activePurePremiums, purePremiumWon);
-      _borrowedActivePP -= aux;
-      purePremiumWon -= aux;
+    int256 maxDeficit = _maxDeficit(deficitRatio());
+    if (_surplus < maxDeficit) {
+      // Covers the excess of deficit first
+      purePremiumWon -= uint256(-_surplus + maxDeficit);
+      _surplus = maxDeficit;
     }
 
     if (address(_seniorEtk) != address(0)) purePremiumWon = _repayLoan(purePremiumWon, _seniorEtk);

package/contracts/Reserve.sol

@@ -2,8 +2,11 @@
 pragma solidity ^0.8.0;
 
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IAssetManager} from "./interfaces/IAssetManager.sol";
+import {IAccessManager} from "./interfaces/IAccessManager.sol";
 import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
 
 /**
@@ -14,6 +17,7 @@ import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
  */
 abstract contract Reserve is PolicyPoolComponent {
   using SafeERC20 for IERC20Metadata;
+  using Address for address;
 
   /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
   // solhint-disable-next-line var-name-mixedcase
@@ -27,8 +31,88 @@ abstract contract Reserve is PolicyPoolComponent {
   function _transferTo(address destination, uint256 amount) internal {
     if (amount == 0) return;
     uint256 balance = currency().balanceOf(address(this));
-    if (balance < amount && (amount - balance) < NEGLIGIBLE_AMOUNT) amount = balance;
-    // TODO: asset management
+    if (balance < amount) {
+      address am = address(assetManager());
+      if (am != address(0)) {
+        am.functionDelegateCall(
+          abi.encodeWithSelector(IAssetManager.refillWallet.selector, amount),
+          "Error refilling wallet"
+        );
+      }
+      if ((amount - balance) < NEGLIGIBLE_AMOUNT) amount = balance;
+    }
     currency().safeTransfer(destination, amount);
   }
+
+  function assetManager() public view virtual returns (IAssetManager);
+
+  function _setAssetManager(IAssetManager newAM) internal virtual;
+
+  function _assetEarnings(int256 earnings) internal virtual;
+
+  function setAssetManager(IAssetManager newAM, bool force)
+    external
+    onlyGlobalOrComponentRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
+  {
+    require(
+      address(newAM) == address(0) || address(newAM).isContract(),
+      "The assetManager is not a contract!"
+    );
+    address am = address(assetManager());
+    IAccessManager.GovernanceActions action = IAccessManager.GovernanceActions.setAssetManager;
+    if (am != address(0)) {
+      if (force) {
+        // Ignores success or not
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, bytes memory result) = am.delegatecall(
+          abi.encodeWithSelector(IAssetManager.deinvestAll.selector)
+        );
+        if (!success) {
+          action = IAccessManager.GovernanceActions.setAssetManagerForced;
+        } else {
+          _assetEarnings(abi.decode(result, (int256)));
+        }
+      } else {
+        bytes memory result = am.functionDelegateCall(
+          abi.encodeWithSelector(IAssetManager.deinvestAll.selector)
+        );
+        _assetEarnings(abi.decode(result, (int256)));
+      }
+    }
+    _setAssetManager(newAM);
+    am = address(assetManager());
+    if (am != address(0)) {
+      am.functionDelegateCall(abi.encodeWithSelector(IAssetManager.connect.selector));
+    }
+    _componentChanged(action, address(newAM));
+  }
+
+  function rebalance() public whenNotPaused {
+    address am = address(assetManager());
+    require(am != address(0), "No asset manager");
+    am.functionDelegateCall(abi.encodeWithSelector(IAssetManager.rebalance.selector));
+  }
+
+  function recordEarnings() public whenNotPaused {
+    address am = address(assetManager());
+    require(am != address(0), "No asset manager");
+    bytes memory result = am.functionDelegateCall(
+      abi.encodeWithSelector(IAssetManager.recordEarnings.selector)
+    );
+    _assetEarnings(abi.decode(result, (int256)));
+  }
+
+  function checkpoint() external whenNotPaused {
+    recordEarnings();
+    rebalance();
+  }
+
+  function forwardToAssetManager(bytes memory functionCall)
+    external
+    onlyComponentRole(LEVEL2_ROLE)
+    returns (bytes memory)
+  {
+    address am = address(assetManager());
+    return am.functionDelegateCall(functionCall);
+  }
 }

package/contracts/RiskModule.sol

@@ -189,7 +189,7 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
 
   function setParam(Parameter param, uint256 newValue)
     external
-    onlyPoolRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyGlobalOrComponentRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
     if (param == Parameter.moc) {
@@ -236,6 +236,8 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     } else if (param == Parameter.maxDuration) {
       require(!tweak, "Tweak exceeded");
       _params.maxDuration = uint16(newValue);
+    } else {
+      revert("Invalid param!");
     }
     _parameterChanged(
       IAccessManager.GovernanceActions(
@@ -300,8 +302,9 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
    * @param payout The exposure (maximum payout) of the policy
    * @param premium The premium that will be paid by the policyHolder
    * @param lossProb The probability of having to pay the maximum payout (wad)
+   * @param payer The account that pays for the premium
    * @param expiration The expiration of the policy (timestamp)
-   * @param customer The policy holder
+   * @param onBehalfOf The policy holder
    * @param internalId An id that's unique within this module and it will be used to identify the policy
    */
   function _newPolicy(
@@ -309,18 +312,26 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     uint256 premium,
     uint256 lossProb,
     uint40 expiration,
-    address customer,
+    address payer,
+    address onBehalfOf,
     uint96 internalId
   ) internal whenNotPaused returns (Policy.PolicyData memory) {
+    if (premium == type(uint256).max) {
+      premium = getMinimumPremium(payout, lossProb, expiration);
+    }
     require(premium < payout, "Premium must be less than payout");
     uint40 now_ = uint40(block.timestamp);
     require(expiration > now_, "Expiration must be in the future");
     require(((expiration - now_) / 3600) < _params.maxDuration, "Policy exceeds max duration");
-    require(customer != address(0), "Customer can't be zero address");
+    require(onBehalfOf != address(0), "Customer can't be zero address");
     require(
-      _policyPool.currency().allowance(customer, address(_policyPool)) >= premium,
+      _policyPool.currency().allowance(payer, address(_policyPool)) >= premium,
       "You must allow ENSURO to transfer the premium"
     );
+    require(
+      payer == msg.sender || _policyPool.currency().allowance(payer, msg.sender) >= premium,
+      "Payer must allow caller to transfer the premium"
+    );
     require(payout <= maxPayoutPerPolicy(), "RiskModule: Payout is more than maximum per policy");
     Policy.PolicyData memory policy = Policy.initialize(
       this,
@@ -332,7 +343,7 @@ abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
     );
     _activeExposure += policy.payout;
     require(_activeExposure <= exposureLimit(), "RiskModule: SCR limit exceeded");
-    uint256 policyId = _policyPool.newPolicy(policy, customer, internalId);
+    uint256 policyId = _policyPool.newPolicy(policy, payer, onBehalfOf, internalId);
     policy.id = policyId;
     return policy;
   }

package/contracts/TrustfulRiskModule.sol

@@ -59,10 +59,25 @@ contract TrustfulRiskModule is RiskModule {
     uint256 premium,
     uint256 lossProb,
     uint40 expiration,
-    address customer,
+    address onBehalfOf,
     uint96 internalId
   ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
-    return _newPolicy(payout, premium, lossProb, expiration, customer, internalId).id;
+    address payer = onBehalfOf;
+    if (payer != msg.sender && _policyPool.currency().allowance(payer, msg.sender) < premium)
+      /**
+       * The standard is the payer should be the msg.sender but usually, in this type of module,
+       * the sender is an operative account managed by software, where the onBehalfOf is a more
+       * secure account (hardware wallet) that does the cash movements.
+       * This non standard behaviour allows for a more secure setup, where the sender never manages
+       * cash.
+       * We leverage the currency's allowance mechanism to allow the sender access to the payer's
+       * funds.
+       * Note that this allowance won't be spent, so it can be set as the maximum amount of a single
+       * premium even for multiple policies.
+       */
+      payer = msg.sender;
+
+    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
   }
 
   function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)

package/contracts/interfaces/IAccessManager.sol

@@ -12,12 +12,12 @@ interface IAccessManager is IAccessControlUpgradeable {
   enum GovernanceActions {
     none,
     setTreasury, // Changes PolicyPool treasury address
-    setAssetManager, // Changes PolicyPool AssetManager
+    setAssetManager, // Change in the asset manager strategy of a reserve
     setInsolvencyHook, // Changes PolicyPool InsolvencyHook
     setLPWhitelist, // Changes PolicyPool Liquidity Providers Whitelist
     addRiskModule,
     removeRiskModule,
-    cfgFiller1, // Reserve space for future PolicyPoolConfig actions
+    setAssetManagerForced, // Change in the asset manager strategy of a reserve, forced (deinvest failed)
     cfgFiller2, // Reserve space for future PolicyPoolConfig actions
     cfgFiller3, // Reserve space for future PolicyPoolConfig actions
     cfgFiller4, // Reserve space for future PolicyPoolConfig actions
@@ -59,17 +59,35 @@ interface IAccessManager is IAccessControlUpgradeable {
     last
   }
 
+  function getComponentRole(address component, bytes32 role) external view returns (bytes32);
+
+  function hasComponentRole(
+    address component,
+    bytes32 role,
+    address account,
+    bool alsoGlobal
+  ) external view returns (bool);
+
   function checkRole(bytes32 role, address account) external view;
 
+  function checkRole2(
+    bytes32 role1,
+    bytes32 role2,
+    address account
+  ) external view;
+
   function checkComponentRole(
     address component,
     bytes32 role,
-    address account
+    address account,
+    bool alsoGlobal
   ) external view;
 
-  function checkRole2(
+  function checkComponentRole2(
+    address component,
     bytes32 role1,
     bytes32 role2,
-    address account
+    address account,
+    bool alsoGlobal
   ) external view;
 }

package/contracts/interfaces/IAssetManager.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title IAssetManager - Interface of the asset management strategy that's plugged into the reserves
+ * @author Ensuro
+ */
+interface IAssetManager {
+  event MoneyInvested(uint256 amount);
+  event MoneyDeinvested(uint256 amount);
+  event EarningsRecorded(bool positive, uint256 amount);
+
+  function connect() external;
+
+  function rebalance() external;
+
+  function recordEarnings() external returns (int256);
+
+  function refillWallet(uint256 paymentAmount) external;
+
+  function deinvestAll() external returns (int256);
+}

package/contracts/interfaces/IEToken.sol

@@ -9,6 +9,13 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  * @author Ensuro
  */
 interface IEToken is IERC20 {
+  enum Parameter {
+    liquidityRequirement,
+    minUtilizationRate,
+    maxUtilizationRate,
+    internalLoanInterestRate
+  }
+
   /**
    * @dev Event emitted when part of the funds of the eToken are locked as solvency capital.
    * @param interestRate The annualized interestRate paid for the capital (wad)
@@ -110,12 +117,25 @@ interface IEToken is IERC20 {
    * - Must be called by `policyPool()`
    *
    * Events:
-   * - Emits {PoolBorrowerAdded}
+   * - Emits {InternalBorrowerAdded}
    *
    * @param borrower The address of the _borrower_, a PremiumsAccount that has this eToken as senior or junior eToken.
    */
   function addBorrower(address borrower) external;
 
+  /**
+   * @dev Removes an authorized _borrower_ to the eToken. The _borrower_ can't no longer lock funds or take loans.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - Emits {InternalBorrowerRemoved} with the defaulted debt
+   *
+   * @param borrower The address of the _borrower_, a PremiumsAccount that has this eToken as senior or junior eToken.
+   */
+  function removeBorrower(address borrower) external;
+
   /**
    * @dev Lends `amount` to the borrower (msg.sender), transferring the money to `receiver`. This reduces the
    * `totalSupply()` of the eToken, and stores a debt that will be repaid (hopefully) with `repayLoan`.

package/contracts/interfaces/IPolicyPool.sol

@@ -19,13 +19,6 @@ interface IPolicyPool {
    */
   function access() external view returns (IAccessManager);
 
-  /**
-   * @dev Reference to the {PolicyNFT} contract. This contract it's an ERC721 Token that handles the ownership of the
-   *      policies.
-   * @return The address of the PolicyNFT contract
-   */
-  function policyNFT() external view returns (address);
-
   /**
    * @dev Address of the treasury, that receives protocol fees.
    * @return The address of the treasury
@@ -37,22 +30,24 @@ interface IPolicyPool {
    *
    * Requirements:
    * - `msg.sender` must be an active RiskModule
-   * - `customer` approved the spending of `currency()` for at least `policy.premium`
+   * - `caller` approved the spending of `currency()` for at least `policy.premium`
    * - `internalId` must be unique within `policy.riskModule` and not used before
    *
    * Events:
    * - {PolicyPool-NewPolicy}: with all the details about the policy
-   * - {ERC20-Transfer}: does several transfers from customer address to the different receivers of the premium
+   * - {ERC20-Transfer}: does several transfers from caller address to the different receivers of the premium
    * (see Premium Split in the docs)
    *
    * @param policy A policy created with {Policy-initialize}
-   * @param customer The address of the policy holder and the payer of the premiums
+   * @param caller The pricer that's creating the policy and will pay for the premium
+   * @param policyHolder The address of the policy holder and the payer of the premiums
    * @param internalId A unique id within the RiskModule, that will be used to compute the policy id
    * @return The policy id, identifying the NFT and the policy
    */
   function newPolicy(
     Policy.PolicyData memory policy,
-    address customer,
+    address caller,
+    address policyHolder,
     uint96 internalId
   ) external returns (uint256);
 

package/contracts/interfaces/IPremiumsAccount.sol

@@ -68,4 +68,9 @@ interface IPremiumsAccount {
    * @dev The junior eToken, the primary source of solvency, used if the premiums account is exhausted.
    */
   function juniorEtk() external view returns (IEToken);
+
+  /**
+   * @dev The total amount of premiums hold by this PremiumsAccount
+   */
+  function purePremiums() external view returns (uint256);
 }