@ensuro/core 1.2.7 → 2.0.0-beta10

package/contracts/EToken.sol

@@ -2,139 +2,139 @@
 pragma solidity ^0.8.0;
 
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
-import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
-import {IEToken} from "../interfaces/IEToken.sol";
-import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
-import {IInsolvencyHook} from "../interfaces/IInsolvencyHook.sol";
-import {WadRayMath} from "./WadRayMath.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {Reserve} from "./Reserve.sol";
+import {IEToken} from "./interfaces/IEToken.sol";
+import {IAccessManager} from "./interfaces/IAccessManager.sol";
+import {IPolicyPoolComponent} from "./interfaces/IPolicyPoolComponent.sol";
+import {ILPWhitelist} from "./interfaces/ILPWhitelist.sol";
+import {IAssetManager} from "./interfaces/IAssetManager.sol";
+import {WadRayMath} from "./dependencies/WadRayMath.sol";
+import {TimeScaled} from "./TimeScaled.sol";
 
 /**
  * @title Ensuro ERC20 EToken - interest-bearing token
  * @dev Implementation of the interest/earnings bearing token for the Ensuro protocol.
- *      The _scaleFactor scales the balances stored in _balances. _scaleFactor grows continuoulsly at
- *      _tokenInterestRate.
- *      Every operation that changes the utilization rate (_scr/totalSupply) or the _scrInterestRate, updates
- *      first the _scaleFactor accumulating the interest accrued since _lastScaleUpdate.
+ *      `_tsScaled.scale` scales the balances stored in _balances. _tsScaled (totalSupply scaled) grows
+ *      continuoulsly at tokenInterestRate().
+ *      Every operation that changes the utilization rate (_scr.scr/totalSupply) or the _scr.interestRate, updates
+ *      first the _tsScaled.scale accumulating the interest accrued since _tsScaled.lastUpdate.
  * @custom:security-contact security@ensuro.co
  * @author Ensuro
  */
-contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
-  uint256 public constant MIN_SCALE = 1e17; // 0.0000000001 == 1e-10 in ray
-
+contract EToken is Reserve, IERC20Metadata, IEToken {
   using WadRayMath for uint256;
-
-  uint256 internal constant SECONDS_PER_YEAR = 365 days;
+  using TimeScaled for TimeScaled.ScaledAmount;
+  using SafeERC20 for IERC20Metadata;
+  using SafeCast for uint256;
 
   // Attributes taken from ERC20
   mapping(address => uint256) private _balances;
   mapping(address => mapping(address => uint256)) private _allowances;
-  uint256 private _totalSupply; // non-scaled totalSupply
 
   string private _name;
   string private _symbol;
 
-  uint40 internal _expirationPeriod; // in seconds, the maximum duration of policies this eToken can back up
-  uint256 internal _scaleFactor; // in Ray
-  uint40 internal _lastScaleUpdate;
+  TimeScaled.ScaledAmount internal _tsScaled; // Total Supply scaled
 
-  uint256 internal _scr; // in Wad - Capital locked as Solvency Capital Requirement of backed up policies
-  uint256 internal _scrInterestRate; // in Ray - Interest rate received in exchange of solvency capital
-  uint256 internal _tokenInterestRate; // in Ray - Overall interest rate of the token
-  uint256 internal _liquidityRequirement; // in Ray - Liquidity requirement to lock more than SCR
-  uint256 internal _maxUtilizationRate; // in Ray - Maximum SCR/totalSupply rate for backup up new policies
+  struct Scr {
+    uint128 scr; // in Wad - Capital locked as Solvency Capital Requirement of backed up policies
+    uint64 interestRate; // in Wad - Interest rate received in exchange of solvency capital
+    uint64 tokenInterestRate; // in Wad - Overall interest rate of the token
+  }
 
-  uint256 internal _poolLoan; // in Wad - Capital that was used to pay defaults of the premium pool. Took as a loan.
-  uint256 internal _poolLoanInterestRate; // in Ray
-  uint256 internal _poolLoanScale; // in Ray
-  uint40 internal _poolLoanLastUpdate;
+  Scr internal _scr;
 
-  bool internal _acceptAllRMs; // By defaults, accepts (backs up) any RiskModule;
-  // Exceptions to the accept all or accept none policy defined before
-  mapping(address => bool) internal _acceptExceptions;
+  // Mapping that keeps track of allowed borrowers (PremiumsAccount) and their current debt
+  mapping(address => TimeScaled.ScaledAmount) internal _loans;
 
-  event PoolLoan(uint256 value);
-  event PoolLoanRepaid(uint256 value);
+  struct PackedParams {
+    uint16 liquidityRequirement; // Liquidity requirement to lock more/less than SCR - 4 decimals
+    uint16 minUtilizationRate; // Min utilization rate, to reject deposits that leave UR under this value - 4 decimals
+    uint16 maxUtilizationRate; // Max utilization rate, to reject lockScr that leave UR above this value - 4 decimals
+    uint16 internalLoanInterestRate; // Annualized interest rate charged to internal borrowers (premiums accounts) - 4dec
+    ILPWhitelist whitelist; // Whitelist for deposits and transfers
+  }
 
-  modifier onlyAssetManager() {
-    require(
-      _msgSender() == address(_policyPool.config().assetManager()),
-      "The caller must be the PolicyPool's AssetManager"
-    );
+  PackedParams internal _params;
+
+  IAssetManager internal _assetManager;
+
+  event InternalLoan(address indexed borrower, uint256 value, uint256 amountAsked);
+  event InternalLoanRepaid(address indexed borrower, uint256 value);
+  event InternalBorrowerAdded(address indexed borrower);
+  event InternalBorrowerRemoved(address indexed borrower, uint256 defaultedDebt);
+
+  modifier onlyBorrower() {
+    require(_loans[_msgSender()].scale != 0, "The caller must be a borrower");
     _;
   }
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
+  constructor(IPolicyPool policyPool_) Reserve(policyPool_) {}
 
   /**
    * @dev Initializes the eToken
-   * @param expirationPeriod_ Maximum expirationPeriod (from block.timestamp) of policies to be accepted
-   * @param liquidityRequirement_ Liquidity requirement to allow withdrawal (in Ray - default=1 Ray)
    * @param maxUtilizationRate_ Max utilization rate (scr/totalSupply) (in Ray - default=1 Ray)
-   * @param poolLoanInterestRate_ Rate of loans givencrto the policy pool (in Ray)
+   * @param internalLoanInterestRate_ Rate of loans givencrto the policy pool (in Ray)
    * @param name_ Name of the eToken
    * @param symbol_ Symbol of the eToken
    */
   function initialize(
     string memory name_,
     string memory symbol_,
-    uint40 expirationPeriod_,
-    uint256 liquidityRequirement_,
     uint256 maxUtilizationRate_,
-    uint256 poolLoanInterestRate_
+    uint256 internalLoanInterestRate_
   ) public initializer {
     __PolicyPoolComponent_init();
-    __EToken_init_unchained(
-      name_,
-      symbol_,
-      expirationPeriod_,
-      liquidityRequirement_,
-      maxUtilizationRate_,
-      poolLoanInterestRate_
-    );
+    __EToken_init_unchained(name_, symbol_, maxUtilizationRate_, internalLoanInterestRate_);
   }
 
   // solhint-disable-next-line func-name-mixedcase
   function __EToken_init_unchained(
     string memory name_,
     string memory symbol_,
-    uint40 expirationPeriod_,
-    uint256 liquidityRequirement_,
     uint256 maxUtilizationRate_,
-    uint256 poolLoanInterestRate_
+    uint256 internalLoanInterestRate_
   ) internal initializer {
     _name = name_;
     _symbol = symbol_;
-    _expirationPeriod = expirationPeriod_;
-    _scaleFactor = WadRayMath.ray();
-    _lastScaleUpdate = uint40(block.timestamp);
-    _scr = 0;
-    _scrInterestRate = 0;
-    _tokenInterestRate = 0;
-    _liquidityRequirement = liquidityRequirement_;
-    _maxUtilizationRate = maxUtilizationRate_;
-    _acceptAllRMs = true;
-
-    _poolLoan = 0;
-    _poolLoanInterestRate = poolLoanInterestRate_;
-    _poolLoanScale = WadRayMath.ray();
-    _poolLoanLastUpdate = uint40(block.timestamp);
+    _tsScaled.init();
+    /* _scr = Scr({
+      scr: 0,
+      interestRate: 0,
+      tokenInterestRate: 0
+    }); */
+    _params = PackedParams({
+      maxUtilizationRate: _wadTo4(maxUtilizationRate_),
+      liquidityRequirement: 1e4,
+      minUtilizationRate: 0,
+      internalLoanInterestRate: _wadTo4(internalLoanInterestRate_),
+      whitelist: ILPWhitelist(address(0))
+    });
+
     _validateParameters();
   }
 
   // runs validation on EToken parameters
   function _validateParameters() internal view override {
     require(
-      _liquidityRequirement >= 8e26 && _liquidityRequirement <= 13e26,
+      _params.liquidityRequirement >= 8e3 && _params.liquidityRequirement <= 13e3,
       "Validation: liquidityRequirement must be [0.8, 1.3]"
     );
     require(
-      _maxUtilizationRate >= 5e26 && _maxUtilizationRate <= WadRayMath.RAY,
+      _params.maxUtilizationRate >= 5e3 && _params.maxUtilizationRate <= 1e4,
       "Validation: maxUtilizationRate must be [0.5, 1]"
     );
-    require(_poolLoanInterestRate <= 5e26, "Validation: poolLoanInterestRate must be <= 50%");
+    require(_params.minUtilizationRate <= 1e4, "Validation: minUtilizationRate must be [0, 1]");
+    require(
+      _params.internalLoanInterestRate <= 5e3,
+      "Validation: internalLoanInterestRate must be <= 50%"
+    );
   }
 
   /*** BEGIN ERC20 methods - mainly copied from OpenZeppelin but changes in events and scaledAmount */
@@ -175,7 +175,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
    * @dev See {IERC20-totalSupply}.
    */
   function totalSupply() public view virtual override returns (uint256) {
-    return _totalSupply.wadToRay().rayMul(_calculateCurrentScale()).rayToWad();
+    return _tsScaled.getScaledAmount(tokenInterestRate());
   }
 
   /**
@@ -184,7 +184,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
   function balanceOf(address account) public view virtual override returns (uint256) {
     uint256 principalBalance = _balances[account];
     if (principalBalance == 0) return 0;
-    return principalBalance.wadToRay().rayMul(_calculateCurrentScale()).rayToWad();
+    return _tsScaled.getScale(tokenInterestRate()).rayMul(principalBalance.wadToRay()).rayToWad();
   }
 
   /**
@@ -295,10 +295,6 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     return true;
   }
 
-  function _scaleAmount(uint256 amount) internal view returns (uint256) {
-    return amount.wadToRay().rayDiv(_calculateCurrentScale()).rayToWad();
-  }
-
   /**
    * @dev Moves tokens `amount` from `sender` to `recipient`.
    *
@@ -322,7 +318,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     require(recipient != address(0), "EToken: transfer to the zero address");
 
     _beforeTokenTransfer(sender, recipient, amount);
-    uint256 scaledAmount = _scaleAmount(amount);
+    uint256 scaledAmount = _tsScaled.scaleAmountNow(tokenInterestRate(), amount);
 
     uint256 senderBalance = _balances[sender];
     require(senderBalance >= scaledAmount, "EToken: transfer amount exceeds balance");
@@ -345,9 +341,7 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     require(account != address(0), "EToken: mint to the zero address");
 
     _beforeTokenTransfer(address(0), account, amount);
-    uint256 scaledAmount = _scaleAmount(amount);
-
-    _totalSupply += scaledAmount;
+    uint256 scaledAmount = _tsScaled.add(amount, tokenInterestRate());
     _balances[account] += scaledAmount;
     emit Transfer(address(0), account, amount);
   }
@@ -367,11 +361,10 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     require(account != address(0), "EToken: burn from the zero address");
     _beforeTokenTransfer(account, address(0), amount);
 
-    uint256 scaledAmount = _scaleAmount(amount);
+    uint256 scaledAmount = _tsScaled.sub(amount, tokenInterestRate());
     uint256 accountBalance = _balances[account];
     require(accountBalance >= scaledAmount, "EToken: burn amount exceeds balance");
     _balances[account] = accountBalance - scaledAmount;
-    _totalSupply -= scaledAmount;
 
     emit Transfer(account, address(0), amount);
   }
@@ -419,159 +412,169 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     address from,
     address to,
     uint256 amount
-  ) internal virtual {
+  ) internal virtual whenNotPaused {
     require(
       from == address(0) ||
         to == address(0) ||
-        address(policyPool().config().lpWhitelist()) == address(0) ||
-        policyPool().config().lpWhitelist().acceptsTransfer(this, from, to, amount),
+        address(_params.whitelist) == address(0) ||
+        _params.whitelist.acceptsTransfer(this, from, to, amount),
       "Transfer not allowed - Liquidity Provider not whitelisted"
     );
   }
 
   /*** END ERC20 methods - mainly copied from OpenZeppelin but changes in events and scaledAmount */
 
-  function _updateCurrentScale() internal {
-    if (uint40(block.timestamp) == _lastScaleUpdate) return;
-    _scaleFactor = _calculateCurrentScale();
-    require(_scaleFactor >= MIN_SCALE, "Scale too small, can lead to rounding errors");
-    _lastScaleUpdate = uint40(block.timestamp);
-  }
-
   function _updateTokenInterestRate() internal {
-    uint256 totalSupply_ = this.totalSupply().wadToRay();
-    if (totalSupply_ == 0) _tokenInterestRate = 0;
-    else _tokenInterestRate = _scrInterestRate.rayMul(_scr.wadToRay()).rayDiv(totalSupply_);
-  }
-
-  function _calculateCurrentScale() internal view returns (uint256) {
-    if (uint40(block.timestamp) <= _lastScaleUpdate) return _scaleFactor;
-    uint256 timeDifference = block.timestamp - _lastScaleUpdate;
-    return
-      _scaleFactor.rayMul(
-        ((_tokenInterestRate * timeDifference) / SECONDS_PER_YEAR) + WadRayMath.ray()
-      );
+    uint256 totalSupply_ = this.totalSupply();
+    if (totalSupply_ == 0) _scr.tokenInterestRate = 0;
+    else {
+      _scr.tokenInterestRate = uint256(_scr.interestRate)
+        .wadMul(uint256(_scr.scr))
+        .wadDiv(totalSupply_)
+        .toUint64();
+    }
   }
 
   function getCurrentScale(bool updated) public view returns (uint256) {
-    if (updated) return _calculateCurrentScale();
-    else return _scaleFactor;
+    if (updated) return _tsScaled.getScale(tokenInterestRate());
+    else return uint256(_tsScaled.scale);
   }
 
-  function ocean() public view virtual override returns (uint256) {
+  function fundsAvailable() public view returns (uint256) {
     uint256 totalSupply_ = this.totalSupply();
-    if (totalSupply_ > _scr) return totalSupply_ - _scr;
+    if (totalSupply_ > uint256(_scr.scr)) return totalSupply_ - uint256(_scr.scr);
     else return 0;
   }
 
-  function oceanForNewScr() public view virtual override returns (uint256) {
+  function fundsAvailableToLock() public view returns (uint256) {
     uint256 totalSupply_ = this.totalSupply();
-    if (totalSupply_ > _scr) return (totalSupply_ - _scr).wadMul(_maxUtilizationRate.rayToWad());
+    if (totalSupply_ > uint256(_scr.scr))
+      return (totalSupply_ - uint256(_scr.scr)).wadMul(maxUtilizationRate());
     else return 0;
   }
 
+  function assetManager() public view override returns (IAssetManager) {
+    return _assetManager;
+  }
+
+  function _setAssetManager(IAssetManager newAM) internal override {
+    _assetManager = newAM;
+  }
+
+  // solhint-disable-next-line func-name-mixedcase
+  function _4toWad(uint16 value) internal pure returns (uint256) {
+    // 4 decimals to Wad (18 decimals)
+    return uint256(value) * 1e14;
+  }
+
+  function _wadTo4(uint256 value) internal pure returns (uint16) {
+    // Wad to 4 decimals
+    return (value / 1e14).toUint16();
+  }
+
   function scr() public view virtual override returns (uint256) {
-    return _scr;
+    return uint256(_scr.scr);
   }
 
   function scrInterestRate() public view override returns (uint256) {
-    return _scrInterestRate;
+    return uint256(_scr.interestRate);
   }
 
   function tokenInterestRate() public view override returns (uint256) {
-    return _tokenInterestRate;
+    return uint256(_scr.tokenInterestRate);
   }
 
   function liquidityRequirement() public view returns (uint256) {
-    return _liquidityRequirement;
+    return _4toWad(_params.liquidityRequirement);
   }
 
   function maxUtilizationRate() public view returns (uint256) {
-    return _maxUtilizationRate;
+    return _4toWad(_params.maxUtilizationRate);
   }
 
-  function expirationPeriod() public view returns (uint40) {
-    return _expirationPeriod;
+  function minUtilizationRate() public view returns (uint256) {
+    return _4toWad(_params.minUtilizationRate);
   }
 
   function utilizationRate() public view returns (uint256) {
-    return _scr.wadDiv(this.totalSupply()).wadToRay();
+    return uint256(_scr.scr).wadDiv(this.totalSupply());
   }
 
-  function lockScr(uint256 policyInterestRate, uint256 scrAmount) external override onlyPolicyPool {
-    require(scrAmount <= this.ocean(), "Not enought OCEAN to cover the SCR");
-    _updateCurrentScale();
-    if (_scr == 0) {
-      _scr = scrAmount;
-      _scrInterestRate = policyInterestRate;
+  function lockScr(uint256 scrAmount, uint256 policyInterestRate)
+    external
+    override
+    onlyBorrower
+    whenNotPaused
+  {
+    require(
+      scrAmount <= this.fundsAvailableToLock(),
+      "Not enought funds available to cover the SCR"
+    );
+    _tsScaled.updateScale(tokenInterestRate());
+    if (_scr.scr == 0) {
+      _scr.scr = scrAmount.toUint128();
+      _scr.interestRate = policyInterestRate.toUint64();
     } else {
-      uint256 origScr = _scr.wadToRay();
-      _scr += scrAmount;
-      _scrInterestRate = (_scrInterestRate.rayMul(origScr) +
-        policyInterestRate.rayMul(scrAmount.wadToRay())).rayDiv(_scr.wadToRay());
+      uint256 origScr = uint256(_scr.scr);
+      uint256 newScr = origScr + scrAmount;
+      _scr.interestRate = (uint256(_scr.interestRate).wadMul(origScr) +
+        policyInterestRate.wadMul(scrAmount)).wadDiv(newScr).toUint64();
+      _scr.scr = newScr.toUint128();
     }
     emit SCRLocked(policyInterestRate, scrAmount);
     _updateTokenInterestRate();
   }
 
-  function unlockScr(uint256 policyInterestRate, uint256 scrAmount)
-    external
-    override
-    onlyPolicyPool
-  {
-    require(scrAmount <= _scr, "Current SCR less than the amount you want to unlock");
-    _updateCurrentScale();
+  function unlockScr(
+    uint256 scrAmount,
+    uint256 policyInterestRate,
+    int256 adjustment
+  ) external override onlyBorrower {
+    require(scrAmount <= uint256(_scr.scr), "Current SCR less than the amount you want to unlock");
+    _tsScaled.updateScale(tokenInterestRate());
 
-    if (_scr == scrAmount) {
-      _scr = 0;
-      _scrInterestRate = 0;
+    if (uint256(_scr.scr) == scrAmount) {
+      _scr.scr = 0;
+      _scr.interestRate = 0;
     } else {
-      uint256 origScr = _scr.wadToRay();
-      _scr -= scrAmount;
-      _scrInterestRate = (_scrInterestRate.rayMul(origScr) -
-        policyInterestRate.rayMul(scrAmount.wadToRay())).rayDiv(_scr.wadToRay());
+      uint256 origScr = uint256(_scr.scr);
+      uint256 newScr = origScr - scrAmount;
+      _scr.interestRate = (uint256(_scr.interestRate).wadMul(origScr) -
+        policyInterestRate.wadMul(scrAmount)).wadDiv(newScr).toUint64();
+      _scr.scr = newScr.toUint128();
     }
     emit SCRUnlocked(policyInterestRate, scrAmount);
-    _updateTokenInterestRate();
-  }
-
-  function _discreteChange(uint256 amount, bool positive) internal {
-    uint256 newTotalSupply = positive ? (totalSupply() + amount) : (totalSupply() - amount);
-    _scaleFactor = newTotalSupply.wadToRay().rayDiv(_totalSupply.wadToRay());
-    require(_scaleFactor >= MIN_SCALE, "Scale too small, can lead to rounding errors");
-    _updateTokenInterestRate();
+    _discreteChange(adjustment);
   }
 
-  function discreteEarning(uint256 amount, bool positive) external override onlyPolicyPool {
-    _updateCurrentScale();
-    _discreteChange(amount, positive);
+  function _assetEarnings(int256 earnings) internal override {
+    _discreteChange(earnings);
   }
 
-  function assetEarnings(uint256 amount, bool positive) external override onlyAssetManager {
-    _updateCurrentScale();
-    _discreteChange(amount, positive);
+  function _discreteChange(int256 amount) internal {
+    _tsScaled.discreteChange(amount, tokenInterestRate());
+    _updateTokenInterestRate();
   }
 
   function deposit(address provider, uint256 amount)
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
     require(
-      address(policyPool().config().lpWhitelist()) == address(0) ||
-        policyPool().config().lpWhitelist().acceptsDeposit(this, provider, amount),
+      address(_params.whitelist) == address(0) ||
+        _params.whitelist.acceptsDeposit(this, provider, amount),
       "Liquidity Provider not whitelisted"
     );
-    _updateCurrentScale();
     _mint(provider, amount);
     _updateTokenInterestRate();
+    require(utilizationRate() >= minUtilizationRate(), "Deposit rejected - Utilization Rate < min");
     return balanceOf(provider);
   }
 
   function totalWithdrawable() public view virtual override returns (uint256) {
-    uint256 locked = _scr.wadToRay().rayMul(_liquidityRequirement).rayToWad();
+    uint256 locked = uint256(_scr.scr).wadMul(liquidityRequirement());
     uint256 totalSupply_ = totalSupply();
     if (totalSupply_ >= locked) return totalSupply_ - locked;
     else return 0;
@@ -581,173 +584,125 @@ contract EToken is PolicyPoolComponent, IERC20Metadata, IEToken {
     external
     override
     onlyPolicyPool
-    whenNotPaused
     returns (uint256)
   {
-    _updateCurrentScale();
-    uint256 balance = balanceOf(provider);
-    if (balance == 0) return 0;
-    if (amount > balance) amount = balance;
-    uint256 withdrawable = totalWithdrawable();
-    if (amount > withdrawable) amount = withdrawable;
+    amount = Math.min(amount, Math.min(balanceOf(provider), totalWithdrawable()));
     if (amount == 0) return 0;
     _burn(provider, amount);
     _updateTokenInterestRate();
+    _transferTo(provider, amount);
     return amount;
   }
 
-  function accepts(address riskModule, uint40 policyExpiration)
-    public
-    view
-    virtual
-    override
-    returns (bool)
-  {
-    if (paused()) return false;
-    if (_acceptAllRMs == _acceptExceptions[riskModule]) {
-      // all accepted except this one or all rejected and this one is not an exception
-      return false;
+  function addBorrower(address borrower) external override onlyPolicyPool {
+    TimeScaled.ScaledAmount storage loan = _loans[borrower];
+    if (loan.scale == 0) {
+      loan.init();
+      emit InternalBorrowerAdded(borrower);
     }
-    return policyExpiration < (uint40(block.timestamp) + _expirationPeriod);
   }
 
-  function _updatePoolLoanScale() internal {
-    if (uint40(block.timestamp) == _poolLoanLastUpdate) return;
-    _poolLoanScale = _getPoolLoanScale();
-    _poolLoanLastUpdate = uint40(block.timestamp);
+  function removeBorrower(address borrower) external override onlyPolicyPool {
+    uint256 defaultedDebt = getLoan(borrower);
+    delete _loans[borrower];
+    emit InternalBorrowerRemoved(borrower, defaultedDebt);
   }
 
-  function _maxNegativeAdjustment() internal view returns (uint256) {
-    uint256 ts = totalSupply();
-    uint256 minTs = _totalSupply.wadToRay().rayMul(MIN_SCALE * 10).rayToWad();
-    if (ts > minTs) return ts - minTs;
-    else return 0;
-  }
-
-  function lendToPool(uint256 amount, bool fromOcean)
-    external
-    override
-    onlyPolicyPool
-    returns (uint256)
-  {
-    if (fromOcean && amount > ocean()) amount = ocean();
-    if (!fromOcean && amount > totalSupply()) amount = totalSupply();
-    if (amount > _maxNegativeAdjustment()) {
-      amount = _maxNegativeAdjustment();
-      if (amount == 0) return amount;
-    }
-    if (_poolLoan == 0) {
-      _poolLoan = amount;
-      _poolLoanScale = WadRayMath.ray();
-      _poolLoanLastUpdate = uint40(block.timestamp);
-    } else {
-      _updatePoolLoanScale();
-      _poolLoan += amount.wadToRay().rayDiv(_poolLoanScale).rayToWad();
-    }
-    _updateCurrentScale(); // shouldn't do anything because lendToPool is after unlock_scr but doing anyway
-    _discreteChange(amount, false);
-    emit PoolLoan(amount);
-    if (!fromOcean && _scr > totalSupply()) {
-      // Notify insolvency_hook - Insuficient solvency
-      IInsolvencyHook hook = _policyPool.config().insolvencyHook();
-      if (address(hook) != address(0)) {
-        hook.insolventEToken(this, _scr - totalSupply());
-      }
-    }
-    return amount;
-  }
-
-  function repayPoolLoan(uint256 amount) external override onlyPolicyPool {
-    _updatePoolLoanScale();
-    _poolLoan = (getPoolLoan() - amount).wadToRay().rayDiv(_poolLoanScale).rayToWad();
-    _updateCurrentScale(); // shouldn't do anything because lendToPool is after unlock_scr but doing anyway
-    _discreteChange(amount, true);
-    emit PoolLoanRepaid(amount);
-  }
-
-  function _getPoolLoanScale() internal view returns (uint256) {
-    if (uint40(block.timestamp) <= _poolLoanLastUpdate) return _poolLoanScale;
-    uint256 timeDifference = block.timestamp - _poolLoanLastUpdate;
-    return
-      _poolLoanScale.rayMul(
-        ((_poolLoanInterestRate * timeDifference) / SECONDS_PER_YEAR) + WadRayMath.ray()
-      );
-  }
-
-  function getPoolLoan() public view virtual override returns (uint256) {
-    if (_poolLoan == 0) return 0;
-    return _poolLoan.wadToRay().rayMul(_getPoolLoanScale()).rayToWad();
+  function internalLoan(
+    uint256 amount,
+    address receiver,
+    bool fromAvailable
+  ) external override onlyBorrower whenNotPaused returns (uint256) {
+    uint256 amountAsked = amount;
+    amount = Math.min(
+      Math.min(amount, fromAvailable ? fundsAvailable() : totalSupply()),
+      _tsScaled.maxNegativeAdjustment(tokenInterestRate())
+    );
+    if (amount == 0) return amountAsked;
+    TimeScaled.ScaledAmount storage loan = _loans[_msgSender()];
+    loan.add(amount, internalLoanInterestRate());
+    _discreteChange(-int256(amount));
+    _transferTo(receiver, amount);
+    emit InternalLoan(_msgSender(), amount, amountAsked);
+    return amountAsked - amount;
   }
 
-  function poolLoanInterestRate() public view returns (uint256) {
-    return _poolLoanInterestRate;
+  function repayLoan(uint256 amount, address onBehalfOf) external override {
+    // Anyone can call this method, since it has to pay
+    currency().safeTransferFrom(_msgSender(), address(this), amount);
+    TimeScaled.ScaledAmount storage loan = _loans[onBehalfOf];
+    require(loan.scale != 0, "Not a registered borrower");
+    loan.sub(amount, internalLoanInterestRate());
+    _discreteChange(int256(amount));
+    emit InternalLoanRepaid(onBehalfOf, amount);
   }
 
-  function acceptAllRMs() public view returns (bool) {
-    return _acceptAllRMs;
+  function getLoan(address borrower) public view virtual override returns (uint256) {
+    TimeScaled.ScaledAmount storage loan = _loans[borrower];
+    return loan.getScaledAmount(internalLoanInterestRate());
   }
 
-  function isAcceptException(address riskModule) public view returns (bool) {
-    return _acceptExceptions[riskModule];
+  function internalLoanInterestRate() public view returns (uint256) {
+    return _4toWad(_params.internalLoanInterestRate);
   }
 
-  function setPoolLoanInterestRate(uint256 newRate)
+  function setParam(Parameter param, uint256 newValue)
     external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyGlobalOrComponentRole2(LEVEL2_ROLE, LEVEL3_ROLE)
   {
     bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakRay(_poolLoanInterestRate, newRate, 3e26),
-      "Tweak exceeded: poolLoanInterestRate tweaks only up to 30%"
+    if (param == Parameter.liquidityRequirement) {
+      require(
+        !tweak || _isTweakWad(liquidityRequirement(), newValue, 1e17),
+        "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
+      );
+      _params.liquidityRequirement = _wadTo4(newValue);
+    } else if (param == Parameter.minUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(minUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: minUtilizationRate tweaks only up to 30%"
+      );
+      _params.minUtilizationRate = _wadTo4(newValue);
+    } else if (param == Parameter.maxUtilizationRate) {
+      require(
+        !tweak || _isTweakWad(maxUtilizationRate(), newValue, 3e17),
+        "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
+      );
+      _params.maxUtilizationRate = _wadTo4(newValue);
+    } else if (param == Parameter.internalLoanInterestRate) {
+      require(
+        !tweak || _isTweakWad(internalLoanInterestRate(), newValue, 3e17),
+        "Tweak exceeded: internalLoanInterestRate tweaks only up to 30%"
+      );
+      // This call changes the interest rate without updating the current loans up to this point
+      // So, if interest rate goes from 5% to 6%, this change will be retroactive to the lastUpdate of each
+      // loan. Since it's a permissioned call, I'm ok with this. If a caller wants to reduce the impact, it can
+      // issue 1 wei repayLoan to each active loan, forcing the update of the scales
+      _params.internalLoanInterestRate = _wadTo4(newValue);
+    }
+    _parameterChanged(
+      IAccessManager.GovernanceActions(
+        uint256(IAccessManager.GovernanceActions.setLiquidityRequirement) + uint256(param)
+      ),
+      newValue,
+      tweak
     );
-    _updatePoolLoanScale();
-    _poolLoanInterestRate = newRate;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setPoolLoanInterestRate, newRate, tweak);
   }
 
-  function setLiquidityRequirement(uint256 newRate)
+  function setWhitelist(ILPWhitelist lpWhitelist_)
     external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyGlobalOrComponentRole2(GUARDIAN_ROLE, LEVEL1_ROLE)
   {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakRay(_liquidityRequirement, newRate, 1e26),
-      "Tweak exceeded: liquidityRequirement tweaks only up to 10%"
-    );
-    _liquidityRequirement = newRate;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setLiquidityRequirement, newRate, tweak);
-  }
-
-  function setMaxUtilizationRate(uint256 newRate) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
     require(
-      !tweak || _isTweakRay(_maxUtilizationRate, newRate, 3e26),
-      "Tweak exceeded: maxUtilizationRate tweaks only up to 30%"
-    );
-    _maxUtilizationRate = newRate;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMaxUtilizationRate, newRate, tweak);
-  }
-
-  function setAcceptAllRMs(bool acceptAllRMs_) external onlyPoolRole(LEVEL2_ROLE) {
-    _acceptAllRMs = acceptAllRMs_;
-    _parameterChanged(
-      IPolicyPoolConfig.GovernanceActions.setAcceptAllRMs,
-      acceptAllRMs_ ? 1 : 0,
-      false
+      address(lpWhitelist_) == address(0) ||
+        IPolicyPoolComponent(address(lpWhitelist_)).policyPool() == _policyPool,
+      "Component not linked to this PolicyPool"
     );
+    _params.whitelist = lpWhitelist_;
+    _componentChanged(IAccessManager.GovernanceActions.setLPWhitelist, address(lpWhitelist_));
   }
 
-  function setAcceptException(address riskModule, bool isException)
-    external
-    onlyPoolRole(LEVEL2_ROLE)
-  {
-    _acceptExceptions[riskModule] = isException;
-    uint256 value = uint160(riskModule);
-    if (!isException) value |= (1 << 255); // if changed to NOT exception activate first bit
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setAcceptException, value, false);
-  }
-
-  function getInvestable() public view virtual override returns (uint256) {
-    return _scr + ocean() + getPoolLoan();
+  function whitelist() external view returns (ILPWhitelist) {
+    return _params.whitelist;
   }
 }