@ensuro/core 1.2.7 → 2.0.0-beta3

package/contracts/RiskModule.sol

@@ -2,11 +2,11 @@
 pragma solidity ^0.8.0;
 
 import {WadRayMath} from "./WadRayMath.sol";
-import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
 import {PolicyPoolComponent} from "./PolicyPoolComponent.sol";
-import {IRiskModule} from "../interfaces/IRiskModule.sol";
-import {IPolicyPoolConfig} from "../interfaces/IPolicyPoolConfig.sol";
+import {IRiskModule} from "./interfaces/IRiskModule.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
+import {IPolicyPoolConfig} from "./interfaces/IPolicyPoolConfig.sol";
 import {Policy} from "./Policy.sol";
 
 /**
@@ -15,62 +15,78 @@ import {Policy} from "./Policy.sol";
  * @custom:security-contact security@ensuro.co
  * @author Ensuro
  */
-abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoolComponent {
+abstract contract RiskModule is IRiskModule, PolicyPoolComponent {
   using Policy for Policy.PolicyData;
   using WadRayMath for uint256;
 
-  uint256 internal constant SECONDS_IN_YEAR_RAY = 31536000e27; /* 365 * 24 * 3600 * 10e27 */
+  uint256 internal constant SECONDS_IN_YEAR_WAD = 31536000e18; /* 365 * 24 * 3600 * 10e18 */
 
   // For parameters that can be changed by the risk module provider
   bytes32 public constant RM_PROVIDER_ROLE = keccak256("RM_PROVIDER_ROLE");
 
+  /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
+  IPremiumsAccount internal immutable _premiumsAccount;
+
   string private _name;
-  uint256 internal _scrPercentage; // in ray - Solvency Capital Requirement percentage, to calculate
-  // capital requirement as % of (payout - premium)
-  uint256 internal _moc; // in ray - Margin Of Conservativism - factor that multiplies lossProb
-  // to calculate purePremium
-  uint256 internal _ensuroFee; // in ray - % of pure premium that will go for Ensuro treasury
-  uint256 internal _scrInterestRate; // in ray - % of interest to charge for the SCR
-  uint256 internal _maxScrPerPolicy; // in wad - Max SCR per policy
-  uint256 internal _scrLimit; // in wad - Max SCR to be allocated to this module
-  uint256 internal _totalScr; // in wad - Current SCR allocated to this module
+
+  struct PackedParams {
+    uint16 moc; // Margin Of Conservativism - factor that multiplies lossProb - 4 decimals
+    uint16 jrCollRatio; // Collateralization Ratio to compute Junior solvency as % of payout - 4 decimals
+    uint16 collRatio; // Collateralization Ratio to compute solvency requirement as % of payout - 4 decimals
+    uint16 ensuroPpFee; // % of pure premium that will go for Ensuro treasury - 4 decimals
+    uint16 ensuroCocFee; // % of CoC that will go for Ensuro treasury - 4 decimals
+    uint16 jrRoc; // Return on Capital paid to Junior LPs - Annualized Percentage - 4 decimals
+    uint16 srRoc; // Return on Capital paid to Senior LPs - Annualized Percentage - 4 decimals
+    uint32 maxPayoutPerPolicy; // Max Payout per Policy - 2 decimals
+    uint32 exposureLimit; // Max exposure (sum of payouts) to be allocated to this module - 0 decimals
+    uint16 maxDuration; // Max policy duration (in hours)
+  }
+
+  PackedParams internal _params;
+
+  uint256 internal _activeExposure; // in wad - Current exposure of active policies
 
   address internal _wallet; // Address of the RiskModule provider
 
   /// @custom:oz-upgrades-unsafe-allow constructor
-  // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_) PolicyPoolComponent(policyPool_) {}
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
+    PolicyPoolComponent(policyPool_)
+  {
+    require(
+      PolicyPoolComponent(address(premiumsAccount_)).policyPool() == policyPool_,
+      "The PremiumsAccount must be part of the Pool"
+    );
+    _premiumsAccount = premiumsAccount_;
+  }
 
   /**
    * @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 pure premium that will go for Ensuro treasury (in ray)
-   * @param scrInterestRate_ % of interest to charge for the SCR (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 collRatio_ Collateralization ratio to compute solvency requirement as % of payout (in wad)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in wad)
+   * @param srRoc_ return on capital paid to LPs (annualized percentage - in wad)
+   * @param maxPayoutPerPolicy_ Maximum payout per policy (in wad)
+   * @param exposureLimit_ Max exposure (sum of payouts) to be allocated to this module (in wad)
    * @param wallet_ Address of the RiskModule provider
    */
   // solhint-disable-next-line func-name-mixedcase
   function __RiskModule_init(
     string memory name_,
-    uint256 scrPercentage_,
-    uint256 ensuroFee_,
-    uint256 scrInterestRate_,
-    uint256 maxScrPerPolicy_,
-    uint256 scrLimit_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
     address wallet_
   ) internal initializer {
-    __AccessControl_init();
     __PolicyPoolComponent_init();
     __RiskModule_init_unchained(
       name_,
-      scrPercentage_,
-      ensuroFee_,
-      scrInterestRate_,
-      maxScrPerPolicy_,
-      scrLimit_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
       wallet_
     );
   }
@@ -78,40 +94,50 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
   // solhint-disable-next-line func-name-mixedcase
   function __RiskModule_init_unchained(
     string memory name_,
-    uint256 scrPercentage_,
-    uint256 ensuroFee_,
-    uint256 scrInterestRate_,
-    uint256 maxScrPerPolicy_,
-    uint256 scrLimit_,
+    uint256 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
     address wallet_
   ) internal initializer {
     _name = name_;
-    _scrPercentage = scrPercentage_;
-    _moc = WadRayMath.RAY;
-    _ensuroFee = ensuroFee_;
-    _scrInterestRate = scrInterestRate_;
-    _maxScrPerPolicy = maxScrPerPolicy_;
-    _scrLimit = scrLimit_;
-    _totalScr = 0;
+    _params = PackedParams({
+      moc: 1e4,
+      jrCollRatio: 0,
+      collRatio: _wadTo4(collRatio_),
+      ensuroPpFee: _wadTo4(ensuroPpFee_),
+      ensuroCocFee: 0,
+      jrRoc: 0,
+      srRoc: _wadTo4(srRoc_),
+      maxPayoutPerPolicy: _amountToX(2, maxPayoutPerPolicy_),
+      exposureLimit: _amountToX(0, exposureLimit_),
+      maxDuration: 24 * 365 // default = 1 year
+    });
+    _activeExposure = 0;
     _wallet = wallet_;
-    _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
     _validateParameters();
   }
 
   // runs validation on RiskModule parameters
   function _validateParameters() internal view override {
+    require(_params.jrCollRatio <= 1e4, "Validation: jrCollRatio must be <=1");
+    require(_params.collRatio <= 1e4 && _params.collRatio > 0, "Validation: collRatio must be <=1");
+    require(_params.collRatio >= _params.jrCollRatio, "Validation: collRatio >= jrCollRatio");
+    require(_params.moc <= 4e4 && _params.moc >= 5e3, "Validation: moc must be [0.5, 4]");
+    require(_params.ensuroPpFee <= 1e4, "Validation: ensuroPpFee must be <= 1");
+    require(_params.ensuroCocFee <= 1e4, "Validation: ensuroCocFee must be <= 1");
+    require(_params.srRoc <= 1e4, "Validation: srRoc must be <= 1 (100%)");
+    require(_params.jrRoc <= 1e4, "Validation: jrRoc must be <= 1 (100%)");
+    // _maxPayoutPerPolicy no limits
     require(
-      _scrPercentage <= WadRayMath.RAY && _scrPercentage > 0,
-      "Validation: scrPercentage must be <=1"
+      exposureLimit() >= _activeExposure,
+      "Validation: exposureLimit can't be less than actual activeExposure"
     );
     require(
-      _moc <= (2 * WadRayMath.RAY) && _moc >= (WadRayMath.RAY / 2),
-      "Validation: moc must be [0.5, 2]"
+      _params.exposureLimit > 0 && _params.maxPayoutPerPolicy > 0,
+      "Exposure and MaxPayout must be >0"
     );
-    require(_ensuroFee <= WadRayMath.RAY, "Validation: ensuroFee must be <= 1");
-    require(_scrInterestRate <= WadRayMath.RAY, "Validation: scrInterestRate must be <= 1 (100%)");
-    // _maxScrPerPolicy no limits
-    require(_scrLimit >= _totalScr, "Validation: scrLimit can't be less than actual totalScr");
     require(_wallet != address(0), "Validation: Wallet can't be zero address");
   }
 
@@ -119,127 +145,121 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     return _name;
   }
 
-  function scrPercentage() public view override returns (uint256) {
-    return _scrPercentage;
-  }
-
-  function moc() public view override returns (uint256) {
-    return _moc;
-  }
-
-  function ensuroFee() public view override returns (uint256) {
-    return _ensuroFee;
+  // 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 scrInterestRate() public view override returns (uint256) {
-    return _scrInterestRate;
+  function _wadTo4(uint256 value) internal pure returns (uint16) {
+    // Wad to 4 decimals
+    return uint16(value / 1e14);
   }
 
-  function maxScrPerPolicy() public view override returns (uint256) {
-    return _maxScrPerPolicy;
+  // solhint-disable-next-line func-name-mixedcase
+  function _XtoAmount(uint8 decimals, uint32 value) internal view returns (uint256) {
+    // X decimals to Wad (18 decimals)
+    return uint256(value) * 10**(currency().decimals() - decimals);
   }
 
-  function scrLimit() public view override returns (uint256) {
-    return _scrLimit;
+  function _amountToX(uint8 decimals, uint256 value) internal view returns (uint32) {
+    // Wad to X decimals
+    return uint32(value / 10**(currency().decimals() - decimals));
   }
 
-  function totalScr() public view override returns (uint256) {
-    return _totalScr;
+  function maxPayoutPerPolicy() public view override returns (uint256) {
+    return _XtoAmount(2, _params.maxPayoutPerPolicy);
   }
 
-  function wallet() public view override returns (address) {
-    return _wallet;
+  function exposureLimit() public view override returns (uint256) {
+    return _XtoAmount(0, _params.exposureLimit);
   }
 
-  function setScrPercentage(uint256 newScrPercentage)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-  {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakRay(_scrPercentage, newScrPercentage, 1e26),
-      "Tweak exceeded: scrPercentage tweaks only up to 10%"
-    );
-    _scrPercentage = newScrPercentage;
-    _parameterChanged(
-      IPolicyPoolConfig.GovernanceActions.setScrPercentage,
-      newScrPercentage,
-      tweak
-    );
+  function maxDuration() public view override returns (uint256) {
+    return _params.maxDuration;
   }
 
-  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;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setMoc, newMoc, tweak);
+  function activeExposure() public view override returns (uint256) {
+    return _activeExposure;
   }
 
-  function setScrInterestRate(uint256 newScrInterestRate)
-    external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
-  {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakRay(_scrInterestRate, newScrInterestRate, 3e26),
-      "Tweak exceeded: scrInterestRate tweaks only up to 30%"
-    );
-    _scrInterestRate = newScrInterestRate;
-    _parameterChanged(
-      IPolicyPoolConfig.GovernanceActions.setScrInterestRate,
-      newScrInterestRate,
-      tweak
-    );
-  }
-
-  function setEnsuroFee(uint256 newEnsuroFee) external onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE) {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakRay(_ensuroFee, newEnsuroFee, 3e26),
-      "Tweak exceeded: ensuroFee tweaks only up to 30%"
-    );
-    _ensuroFee = newEnsuroFee;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setEnsuroFee, newEnsuroFee, tweak);
+  function wallet() public view override returns (address) {
+    return _wallet;
   }
 
-  function setMaxScrPerPolicy(uint256 newMaxScrPerPolicy)
+  function setParam(Parameter param, uint256 newValue)
     external
-    onlyPoolRole2(LEVEL2_ROLE, LEVEL3_ROLE)
+    onlyPoolRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
   {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE);
-    require(
-      !tweak || _isTweakWad(_maxScrPerPolicy, newMaxScrPerPolicy, 3e17),
-      "Tweak exceeded: maxScrPerPolicy tweaks only up to 30%"
-    );
-    _maxScrPerPolicy = newMaxScrPerPolicy;
+    bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
+    if (param == Parameter.moc) {
+      require(!tweak || _isTweakWad(_4toWad(_params.moc), newValue, 1e17), "Tweak exceeded");
+      _params.moc = _wadTo4(newValue);
+    } else if (param == Parameter.jrCollRatio) {
+      require(
+        !tweak || _isTweakWad(_4toWad(_params.jrCollRatio), newValue, 1e17),
+        "Tweak exceeded"
+      );
+      _params.jrCollRatio = _wadTo4(newValue);
+    } else if (param == Parameter.collRatio) {
+      require(!tweak || _isTweakWad(_4toWad(_params.collRatio), newValue, 1e17), "Tweak exceeded");
+      _params.collRatio = _wadTo4(newValue);
+    } else if (param == Parameter.ensuroPpFee) {
+      require(
+        !tweak || _isTweakWad(_4toWad(_params.ensuroPpFee), newValue, 1e17),
+        "Tweak exceeded"
+      );
+      _params.ensuroPpFee = _wadTo4(newValue);
+    } else if (param == Parameter.ensuroCocFee) {
+      require(
+        !tweak || _isTweakWad(_4toWad(_params.ensuroCocFee), newValue, 1e17),
+        "Tweak exceeded"
+      );
+      _params.ensuroCocFee = _wadTo4(newValue);
+    } else if (param == Parameter.jrRoc) {
+      require(!tweak || _isTweakWad(_4toWad(_params.jrRoc), newValue, 1e17), "Tweak exceeded");
+      _params.jrRoc = _wadTo4(newValue);
+    } else if (param == Parameter.srRoc) {
+      require(!tweak || _isTweakWad(_4toWad(_params.srRoc), newValue, 1e17), "Tweak exceeded");
+      _params.srRoc = _wadTo4(newValue);
+    } else if (param == Parameter.maxPayoutPerPolicy) {
+      require(!tweak || _isTweakWad(maxPayoutPerPolicy(), newValue, 1e17), "Tweak exceeded");
+      _params.maxPayoutPerPolicy = _amountToX(2, newValue);
+    } else if (param == Parameter.exposureLimit) {
+      require(newValue >= _activeExposure, "Can't set exposureLimit less than active exposure");
+      require(!tweak || _isTweakWad(exposureLimit(), newValue, 1e17), "Tweak exceeded");
+      require(
+        newValue <= exposureLimit() || hasPoolRole(LEVEL1_ROLE),
+        "Tweak exceeded: Increase requires LEVEL1_ROLE"
+      );
+      _params.exposureLimit = _amountToX(0, newValue);
+    } else if (param == Parameter.maxDuration) {
+      require(!tweak, "Tweak exceeded");
+      _params.maxDuration = uint16(newValue);
+    }
     _parameterChanged(
-      IPolicyPoolConfig.GovernanceActions.setMaxScrPerPolicy,
-      newMaxScrPerPolicy,
+      IPolicyPoolConfig.GovernanceActions(
+        uint256(IPolicyPoolConfig.GovernanceActions.setMoc) + uint256(param)
+      ),
+      newValue,
       tweak
     );
   }
 
-  function setScrLimit(uint256 newScrLimit)
-    external
-    onlyPoolRole3(LEVEL1_ROLE, LEVEL2_ROLE, LEVEL3_ROLE)
-  {
-    bool tweak = !hasPoolRole(LEVEL2_ROLE) && !hasPoolRole(LEVEL1_ROLE);
-    require(
-      !tweak || _isTweakWad(_scrLimit, newScrLimit, 1e17),
-      "Tweak exceeded: scrLimit tweaks only up to 10%"
-    );
-    require(
-      newScrLimit <= _scrLimit ||
-        hasPoolRole(LEVEL1_ROLE) ||
-        _policyPool.totalETokenSupply().wadMul(1e17) > newScrLimit,
-      "Tweak exceeded: Increase, >=10% of the total liquidity, requires LEVEL1_ROLE"
-    );
-    require(newScrLimit >= _totalScr, "Can't set SCR less than current SCR allocation");
-    _scrLimit = newScrLimit;
-    _parameterChanged(IPolicyPoolConfig.GovernanceActions.setScrLimit, newScrLimit, tweak);
+  function params() public view override returns (Params memory ret) {
+    return
+      Params({
+        moc: _4toWad(_params.moc),
+        jrCollRatio: _4toWad(_params.jrCollRatio),
+        collRatio: _4toWad(_params.collRatio),
+        ensuroPpFee: _4toWad(_params.ensuroPpFee),
+        ensuroCocFee: _4toWad(_params.ensuroCocFee),
+        jrRoc: _4toWad(_params.jrRoc),
+        srRoc: _4toWad(_params.srRoc)
+      });
   }
 
-  function setWallet(address wallet_) external onlyRole(RM_PROVIDER_ROLE) {
+  function setWallet(address wallet_) external onlyComponentRole(RM_PROVIDER_ROLE) {
     _wallet = wallet_;
     _parameterChanged(
       IPolicyPoolConfig.GovernanceActions.setWallet,
@@ -253,16 +273,41 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     uint256 lossProb,
     uint40 expiration
   ) public view returns (uint256) {
-    uint256 purePremium = payout.wadToRay().rayMul(lossProb.rayMul(moc())).rayToWad();
-    uint256 scr = payout.wadMul(scrPercentage().rayToWad()) - purePremium;
-    uint256 interestRate = (
-      (scrInterestRate() * (expiration - block.timestamp)).rayDiv(SECONDS_IN_YEAR_RAY)
-    ).rayToWad();
-    uint256 premiumForLps = scr.wadMul(interestRate);
-    uint256 premiumForEnsuro = (purePremium + premiumForLps).wadMul(ensuroFee().rayToWad());
-    return purePremium + premiumForEnsuro + premiumForLps;
+    Params memory p = params();
+    uint256 purePremium = payout.wadMul(lossProb.wadMul(p.moc));
+    uint256 jrScr = payout.wadMul(p.jrCollRatio);
+    if (jrScr > purePremium) {
+      jrScr -= purePremium;
+    } else {
+      jrScr = 0;
+    }
+    uint256 srScr = payout.wadMul(p.collRatio);
+    if (srScr > (purePremium + jrScr)) {
+      srScr -= purePremium + jrScr;
+    } else {
+      srScr = 0;
+    }
+    uint256 jrCoc = jrScr.wadMul(
+      (p.jrRoc * (expiration - block.timestamp)).wadDiv(SECONDS_IN_YEAR_WAD)
+    );
+    uint256 srCoc = srScr.wadMul(
+      (p.srRoc * (expiration - block.timestamp)).wadDiv(SECONDS_IN_YEAR_WAD)
+    );
+    uint256 ensuroCommission = purePremium.wadMul(p.ensuroPpFee) +
+      (jrCoc + srCoc).wadMul(p.ensuroCocFee);
+    return purePremium + ensuroCommission + (jrCoc + srCoc);
   }
 
+  /**
+   * @dev Called from child contracts to create policies (after they validated the pricing)
+   *
+   * @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 expiration The expiration of the policy (timestamp)
+   * @param customer The policy holder
+   * @param internalId An id that's unique within this module and it will be used to identify the policy
+   */
   function _newPolicy(
     uint256 payout,
     uint256 premium,
@@ -272,31 +317,38 @@ abstract contract RiskModule is IRiskModule, AccessControlUpgradeable, PolicyPoo
     uint96 internalId
   ) internal whenNotPaused returns (Policy.PolicyData memory) {
     require(premium < payout, "Premium must be less than payout");
-    require(expiration > uint40(block.timestamp), "Expiration must be in the future");
+    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(
       _policyPool.currency().allowance(customer, address(_policyPool)) >= premium,
       "You must allow ENSURO to transfer the premium"
     );
+    require(payout <= maxPayoutPerPolicy(), "RiskModule: Payout is more than maximum per policy");
     Policy.PolicyData memory policy = Policy.initialize(
       this,
+      params(),
       premium,
       payout,
       lossProb,
       expiration
     );
-    require(policy.scr <= _maxScrPerPolicy, "RiskModule: SCR is more than maximum per policy");
-    _totalScr += policy.scr;
-    require(_totalScr <= _scrLimit, "RiskModule: SCR limit exceeded");
+    _activeExposure += policy.payout;
+    require(_activeExposure <= exposureLimit(), "RiskModule: SCR limit exceeded");
     uint256 policyId = _policyPool.newPolicy(policy, customer, internalId);
     policy.id = policyId;
     return policy;
   }
 
-  function releaseScr(uint256 scrAmount) external override onlyPolicyPool {
+  function releaseExposure(uint256 payout) external override onlyPolicyPool {
     // In the Python protype this function is called `remove_policy` and receives
     // all the policy. Since we just need the amount, for performance reasons
-    // we just send the amount and the method is called releaseScr
-    _totalScr -= scrAmount;
+    // we just send the amount and the method is called releaseExposure
+    _activeExposure -= payout;
+  }
+
+  function premiumsAccount() external view override returns (IPremiumsAccount) {
+    return _premiumsAccount;
   }
 }

package/contracts/TimeScaled.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {WadRayMath} from "./WadRayMath.sol";
+
+/**
+ * @title TimeScaled
+ * @dev Library for packed amounts that increase continuoulsly with a scale factor
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+library TimeScaled {
+  using WadRayMath for uint256;
+
+  uint256 internal constant SECONDS_PER_YEAR = 365 days;
+  uint128 public constant MIN_SCALE = 1e17; // 0.0000000001 == 1e-10 in ray
+
+  struct ScaledAmount {
+    uint128 scale;
+    uint96 amount;
+    uint32 lastUpdate;
+  }
+
+  function updateScale(ScaledAmount storage scaledAmount, uint256 interestRate) internal {
+    if (scaledAmount.lastUpdate >= uint32(block.timestamp)) return;
+    if (scaledAmount.amount == 0) {
+      scaledAmount.lastUpdate = uint32(block.timestamp);
+    } else {
+      scaledAmount.scale = uint128(getScale(scaledAmount, interestRate));
+      scaledAmount.lastUpdate = uint32(block.timestamp);
+    }
+  }
+
+  function getScale(ScaledAmount storage scaledAmount, uint256 interestRate)
+    internal
+    view
+    returns (uint256)
+  {
+    uint32 now_ = uint32(block.timestamp);
+    if (scaledAmount.lastUpdate >= now_) {
+      return scaledAmount.scale;
+    }
+    uint256 timeDifference = uint256(now_ - scaledAmount.lastUpdate);
+    return
+      uint256(scaledAmount.scale).rayMul(
+        ((interestRate.wadToRay() * timeDifference) / SECONDS_PER_YEAR) + WadRayMath.ray()
+      );
+  }
+
+  function getScaledAmount(ScaledAmount storage scaledAmount, uint256 interestRate)
+    internal
+    view
+    returns (uint256)
+  {
+    return
+      uint256(scaledAmount.amount)
+        .wadToRay()
+        .rayMul(getScale(scaledAmount, interestRate))
+        .rayToWad();
+  }
+
+  function init(ScaledAmount storage scaledAmount) internal {
+    scaledAmount.scale = uint128(WadRayMath.ray());
+    scaledAmount.amount = 0;
+    scaledAmount.lastUpdate = uint32(block.timestamp);
+  }
+
+  function scaleAmount(ScaledAmount storage scaledAmount, uint256 toScale)
+    internal
+    view
+    returns (uint256)
+  {
+    return toScale.wadToRay().rayDiv(uint256(scaledAmount.scale)).rayToWad();
+  }
+
+  function scaleAmountNow(
+    ScaledAmount storage scaledAmount,
+    uint256 interestRate,
+    uint256 toScale
+  ) internal view returns (uint256) {
+    return toScale.wadToRay().rayDiv(getScale(scaledAmount, interestRate)).rayToWad();
+  }
+
+  function add(
+    ScaledAmount storage scaledAmount,
+    uint256 amount,
+    uint256 interestRate
+  ) internal returns (uint256) {
+    updateScale(scaledAmount, interestRate);
+    uint256 scaledAdd = scaleAmount(scaledAmount, amount);
+    scaledAmount.amount += uint96(scaledAdd);
+    return scaledAdd;
+  }
+
+  function sub(
+    ScaledAmount storage scaledAmount,
+    uint256 amount,
+    uint256 interestRate
+  ) internal returns (uint256) {
+    updateScale(scaledAmount, interestRate);
+    uint256 scaledSub = scaleAmount(scaledAmount, amount);
+    scaledAmount.amount -= uint96(scaledSub);
+    if (scaledAmount.amount == 0) {
+      // Reset scale if amount == 0
+      scaledAmount.scale = uint128(WadRayMath.ray());
+    }
+    return scaledSub;
+  }
+
+  function discreteChange(
+    ScaledAmount storage scaledAmount,
+    int256 amount,
+    uint256 interestRate
+  ) internal {
+    updateScale(scaledAmount, interestRate);
+    uint256 newScaledAmount = uint256(int256(getScaledAmount(scaledAmount, interestRate)) + amount);
+    scaledAmount.scale = uint128(
+      newScaledAmount.wadToRay().rayDiv(uint256(scaledAmount.amount).wadToRay())
+    );
+    require(scaledAmount.scale >= MIN_SCALE, "Scale too small, can lead to rounding errors");
+  }
+
+  function maxNegativeAdjustment(ScaledAmount storage scaledAmount, uint256 interestRate)
+    internal
+    view
+    returns (uint256)
+  {
+    uint256 ts = getScaledAmount(scaledAmount, interestRate);
+    uint256 minTs = uint256(scaledAmount.amount).wadToRay().rayMul(MIN_SCALE * 10).rayToWad();
+    if (ts > minTs) return ts - minTs;
+    else return 0;
+  }
+}