@ensuro/core 2.7.0 → 2.8.0-beta2

package/contracts/TimeScaled.sol

@@ -35,11 +35,7 @@ library TimeScaled {
     }
   }
 
-  function getScale(ScaledAmount storage scaledAmount, uint256 interestRate)
-    internal
-    view
-    returns (uint256)
-  {
+  function getScale(ScaledAmount storage scaledAmount, uint256 interestRate) internal view returns (uint256) {
     uint32 now_ = uint32(block.timestamp);
     if (scaledAmount.lastUpdate >= now_) {
       return scaledAmount.scale;
@@ -51,16 +47,8 @@ library TimeScaled {
       );
   }
 
-  function getScaledAmount(ScaledAmount storage scaledAmount, uint256 interestRate)
-    internal
-    view
-    returns (uint256)
-  {
-    return
-      uint256(scaledAmount.amount)
-        .wadToRay()
-        .rayMul(getScale(scaledAmount, interestRate))
-        .rayToWad();
+  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 {
@@ -69,11 +57,7 @@ library TimeScaled {
     scaledAmount.lastUpdate = uint32(block.timestamp);
   }
 
-  function scaleAmount(ScaledAmount storage scaledAmount, uint256 toScale)
-    internal
-    view
-    returns (uint256)
-  {
+  function scaleAmount(ScaledAmount storage scaledAmount, uint256 toScale) internal view returns (uint256) {
     return toScale.wadToRay().rayDiv(uint256(scaledAmount.scale)).rayToWad();
   }
 
@@ -85,22 +69,14 @@ library TimeScaled {
     return toScale.wadToRay().rayDiv(getScale(scaledAmount, interestRate)).rayToWad();
   }
 
-  function add(
-    ScaledAmount storage scaledAmount,
-    uint256 amount,
-    uint256 interestRate
-  ) internal returns (uint256) {
+  function add(ScaledAmount storage scaledAmount, uint256 amount, uint256 interestRate) internal returns (uint256) {
     updateScale(scaledAmount, interestRate);
     uint256 scaledAdd = scaleAmount(scaledAmount, amount);
     scaledAmount.amount += scaledAdd.toUint96();
     return scaledAdd;
   }
 
-  function sub(
-    ScaledAmount storage scaledAmount,
-    uint256 amount,
-    uint256 interestRate
-  ) internal returns (uint256) {
+  function sub(ScaledAmount storage scaledAmount, uint256 amount, uint256 interestRate) internal returns (uint256) {
     updateScale(scaledAmount, interestRate);
     uint256 scaledSub = scaleAmount(scaledAmount, amount);
     scaledAmount.amount -= scaledSub.toUint96();
@@ -111,21 +87,14 @@ library TimeScaled {
     return scaledSub;
   }
 
-  function discreteChange(
-    ScaledAmount storage scaledAmount,
-    int256 amount,
-    uint256 interestRate
-  ) internal {
+  function discreteChange(ScaledAmount storage scaledAmount, int256 amount, uint256 interestRate) internal {
     if (scaledAmount.amount == 0) {
       add(scaledAmount, uint256(amount), interestRate);
       return;
     }
     updateScale(scaledAmount, interestRate);
     uint256 newScaledAmount = uint256(int256(getScaledAmount(scaledAmount, interestRate)) + amount);
-    scaledAmount.scale = newScaledAmount
-      .wadToRay()
-      .rayDiv(uint256(scaledAmount.amount).wadToRay())
-      .toUint112();
+    scaledAmount.scale = newScaledAmount.wadToRay().rayDiv(uint256(scaledAmount.amount).wadToRay()).toUint112();
     require(scaledAmount.scale >= MIN_SCALE, "Scale too small, can lead to rounding errors");
   }
 

package/contracts/TrustfulRiskModule.sol

@@ -5,6 +5,7 @@ import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
 import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
 import {RiskModule} from "./RiskModule.sol";
 import {Policy} from "./Policy.sol";
+import {IERC721} from "@openzeppelin/contracts/interfaces/IERC721.sol";
 
 /**
  * @title Trustful Risk Module
@@ -17,12 +18,11 @@ import {Policy} from "./Policy.sol";
 contract TrustfulRiskModule is RiskModule {
   bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
   bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_ROLE");
+  bytes32 public constant REPLACER_ROLE = keccak256("REPLACER_ROLE");
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
-    RiskModule(policyPool_, premiumsAccount_)
-  {} // solhint-disable-line no-empty-blocks
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_) RiskModule(policyPool_, premiumsAccount_) {}
 
   /**
    * @dev Initializes the RiskModule
@@ -43,15 +43,7 @@ contract TrustfulRiskModule is RiskModule {
     uint256 exposureLimit_,
     address wallet_
   ) public initializer {
-    __RiskModule_init(
-      name_,
-      collRatio_,
-      ensuroPpFee_,
-      srRoc_,
-      maxPayoutPerPolicy_,
-      exposureLimit_,
-      wallet_
-    );
+    __RiskModule_init(name_, collRatio_, ensuroPpFee_, srRoc_, maxPayoutPerPolicy_, exposureLimit_, wallet_);
   }
 
   /**
@@ -79,16 +71,7 @@ contract TrustfulRiskModule is RiskModule {
     address onBehalfOf,
     uint96 internalId
   ) external whenNotPaused onlyComponentRole(PRICER_ROLE) returns (uint256) {
-    return
-      _newPolicy(
-        payout,
-        premium,
-        lossProb,
-        expiration,
-        _getPayer(onBehalfOf, premium),
-        onBehalfOf,
-        internalId
-      ).id;
+    return _newPolicy(payout, premium, lossProb, expiration, _getPayer(onBehalfOf, premium), onBehalfOf, internalId).id;
   }
 
   /**
@@ -115,22 +98,46 @@ contract TrustfulRiskModule is RiskModule {
     uint40 expiration,
     address onBehalfOf,
     uint96 internalId
-  )
-    external
-    whenNotPaused
-    onlyComponentRole(PRICER_ROLE)
-    returns (Policy.PolicyData memory createdPolicy)
-  {
+  ) external whenNotPaused onlyComponentRole(PRICER_ROLE) returns (Policy.PolicyData memory createdPolicy) {
+    return _newPolicy(payout, premium, lossProb, expiration, _getPayer(onBehalfOf, premium), onBehalfOf, internalId);
+  }
+
+  /**
+   * @dev Replace a policy with a new one, reusing the premium and the capital locked
+   *
+   * Requirements:
+   * - The caller has been granted componentRole(PRICER_ROLE)
+   *
+   * Emits:
+   * - {PolicyPool.PolicyReplaced}
+   *
+   * @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 internalId An id that's unique within this module and it will be used to identify the policy
+   * @return Returns the id of the created policy
+   */
+  function replacePolicy(
+    Policy.PolicyData calldata oldPolicy,
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    uint96 internalId
+  ) external whenNotPaused onlyComponentRole(REPLACER_ROLE) returns (uint256) {
+    address onBehalfOf = IERC721(address(_policyPool)).ownerOf(oldPolicy.id);
     return
-      _newPolicy(
+      _replacePolicy(
+        oldPolicy,
         payout,
         premium,
         lossProb,
         expiration,
         _getPayer(onBehalfOf, premium),
-        onBehalfOf,
-        internalId
-      );
+        internalId,
+        params()
+      ).id;
   }
 
   function _getPayer(address onBehalfOf, uint256 premium) internal view returns (address payer) {
@@ -165,11 +172,10 @@ contract TrustfulRiskModule is RiskModule {
    * @param policy The policy previously created (from {NewPolicy} event)
    * @param payout The payout to transfer to the policy holder
    */
-  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
-    external
-    onlyComponentRole(RESOLVER_ROLE)
-    whenNotPaused
-  {
+  function resolvePolicy(
+    Policy.PolicyData calldata policy,
+    uint256 payout
+  ) external onlyComponentRole(RESOLVER_ROLE) whenNotPaused {
     _policyPool.resolvePolicy(policy, payout);
   }
 
@@ -187,11 +193,10 @@ contract TrustfulRiskModule is RiskModule {
    * @param customerWon If true, policy.payout is transferred to the policy holder. If false, the policy is resolved
    * without payout and can't be longer claimed.
    */
-  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
-    external
-    onlyComponentRole(RESOLVER_ROLE)
-    whenNotPaused
-  {
+  function resolvePolicyFullPayout(
+    Policy.PolicyData calldata policy,
+    bool customerWon
+  ) external onlyComponentRole(RESOLVER_ROLE) whenNotPaused {
     _policyPool.resolvePolicyFullPayout(policy, customerWon);
   }
 

package/contracts/interfaces/IAccessManager.sol

@@ -108,11 +108,7 @@ interface IAccessManager is IAccessControlUpgradeable {
    * @param role2 Another role such as `keccak256("GUARDIAN_ROLE")` that's global
    * @param account The user address for who we want to verify the permission
    */
-  function checkRole2(
-    bytes32 role1,
-    bytes32 role2,
-    address account
-  ) external view;
+  function checkRole2(bytes32 role1, bytes32 role2, address account) external view;
 
   /**
    * @dev Checks if a user has been granted a given component role and reverts if it doesn't
@@ -122,12 +118,7 @@ interface IAccessManager is IAccessControlUpgradeable {
    * @param alsoGlobal If true, it will accept not only the component role, but also the (global) `role` itself.
    *                   If false, only the component role is accepted
    */
-  function checkComponentRole(
-    address component,
-    bytes32 role,
-    address account,
-    bool alsoGlobal
-  ) external view;
+  function checkComponentRole(address component, bytes32 role, address account, bool alsoGlobal) external view;
 
   /**
    * @dev Checks if a user has been granted any of the two component roles specified and reverts if it doesn't

package/contracts/interfaces/IEToken.sol

@@ -67,11 +67,7 @@ interface IEToken is IERC20 {
    * @param policyInterestRate The annualized interest rate that was paid for the `scrAmount`, must be the same that was
    * sent in `lockScr` call.
    */
-  function unlockScr(
-    uint256 scrAmount,
-    uint256 policyInterestRate,
-    int256 adjustment
-  ) external;
+  function unlockScr(uint256 scrAmount, uint256 policyInterestRate, int256 adjustment) external;
 
   /**
    * @dev Registers a deposit of liquidity in the pool. Called from the PolicyPool, assumes the amount has already been

package/contracts/interfaces/ILPWhitelist.sol

@@ -16,11 +16,7 @@ interface ILPWhitelist {
    * @param amount The amount of the deposit
    * @return true if `provider` deposit is accepted, false if not
    */
-  function acceptsDeposit(
-    IEToken etoken,
-    address provider,
-    uint256 amount
-  ) external view returns (bool);
+  function acceptsDeposit(IEToken etoken, address provider, uint256 amount) external view returns (bool);
 
   /**
    * @dev Indicates whether or not the eTokens can be transferred from `providerFrom` to `providerTo`
@@ -46,9 +42,5 @@ interface ILPWhitelist {
    * @param amount The amount of the withdrawal
    * @return true if `provider` withdraw request is accepted, false if not
    */
-  function acceptsWithdrawal(
-    IEToken etoken,
-    address provider,
-    uint256 amount
-  ) external view returns (bool);
+  function acceptsWithdrawal(IEToken etoken, address provider, uint256 amount) external view returns (bool);
 }

package/contracts/interfaces/IPolicyHolder.sol

@@ -18,11 +18,7 @@ interface IPolicyHolder is IERC721Receiver {
    *
    * The selector can be obtained in Solidity with `IPolicyPool.onPolicyExpired.selector`.
    */
-  function onPolicyExpired(
-    address operator,
-    address from,
-    uint256 policyId
-  ) external returns (bytes4);
+  function onPolicyExpired(address operator, address from, uint256 policyId) external returns (bytes4);
 
   /**
    * @dev Whenever an Policy is resolved with payout > 0, this function is called
@@ -33,10 +29,5 @@ interface IPolicyHolder is IERC721Receiver {
    *
    * The selector can be obtained in Solidity with `IPolicyPool.onPayoutReceived.selector`.
    */
-  function onPayoutReceived(
-    address operator,
-    address from,
-    uint256 policyId,
-    uint256 amount
-  ) external returns (bytes4);
+  function onPayoutReceived(address operator, address from, uint256 policyId, uint256 amount) external returns (bytes4);
 }

package/contracts/interfaces/IPolicyPool.sol

@@ -4,9 +4,39 @@ pragma solidity ^0.8.0;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {Policy} from "../Policy.sol";
 import {IEToken} from "./IEToken.sol";
+import {IRiskModule} from "./IRiskModule.sol";
 import {IAccessManager} from "./IAccessManager.sol";
 
 interface IPolicyPool {
+  /**
+   * @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.
+   *
+   * @param riskModule The risk module that created the policy
+   * @param policy The {Policy-PolicyData} struct with all the immutable fields of the policy.
+   */
+  event NewPolicy(IRiskModule indexed riskModule, Policy.PolicyData policy);
+
+  /**
+   * @dev Event emitted every time a new policy replaces an old Policy Contains all the data about the policy that is
+   * later required for doing operations with the policy like resolution or expiration.
+   *
+   * @param riskModule The risk module that created the policy
+   * @param oldPolicyId The id of the replaced policy.
+   * @param newPolicyId The id of the new policy.
+   */
+  event PolicyReplaced(IRiskModule indexed riskModule, uint256 indexed oldPolicyId, uint256 indexed newPolicyId);
+
+  /**
+   * @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.
+   *
+   * @param riskModule The risk module where that created the policy initially.
+   * @param policyId The unique id of the policy
+   * @param payout The payout that has been paid to the policy holder. 0 when the policy expired.
+   */
+  event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
+
   /**
    * @dev Reference to the main currency (ERC20) used in the protocol
    * @return The address of the currency (e.g. USDC) token used in the protocol
@@ -39,18 +69,44 @@ interface IPolicyPool {
    * (see Premium Split in the docs)
    *
    * @param policy A policy created with {Policy-initialize}
-   * @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 payer The address that will pay for the premium
+   * @param policyHolder The address of the policy holder
    * @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 caller,
+    address payer,
     address policyHolder,
     uint96 internalId
   ) external returns (uint256);
 
+  /**
+   * @dev Replaces a policy with another. Must be called from an active RiskModule
+   *
+   * Requirements:
+   * - `msg.sender` must be an active RiskModule
+   * - `caller` approved the spending of `currency()` for at least `newPolicy_.premium - oldPolicy.premium`
+   * - `internalId` must be unique within `policy.riskModule` and not used before
+   *
+   * Events:
+   * - {PolicyPool-PolicyReplaced}: with all the details about the policy
+   * - {ERC20-Transfer}: does several transfers from caller address to the different receivers of the premium
+   * (see Premium Split in the docs)
+   *
+   * @param oldPolicy A policy created previously and not expired
+   * @param newPolicy_ A policy created with {Policy-initialize}
+   * @param payer The address that will pay for the premium
+   * @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 replacePolicy(
+    Policy.PolicyData memory oldPolicy,
+    Policy.PolicyData memory newPolicy_,
+    address payer,
+    uint96 internalId
+  ) external returns (uint256);
+
   /**
    * @dev Resolves a policy with a payout. Must be called from an active RiskModule
    *

package/contracts/interfaces/IPremiumsAccount.sol

@@ -24,6 +24,22 @@ interface IPremiumsAccount {
    */
   function policyCreated(Policy.PolicyData memory policy) external;
 
+  /**
+   * @dev Replaces a policy with another in PremiumsAccount. Stores the pure premiums difference and
+   * re-locks the aditional funds from junior and senior eTokens.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - {EToken-SCRUnlocked}
+   * - {EToken-SCRLocked}
+   *
+   * @param oldPolicy The policy to replace (created in a previous transaction)
+   * @param newPolicy The policy that will replace the old one (created in this transaction)
+   */
+  function policyReplaced(Policy.PolicyData memory oldPolicy, Policy.PolicyData memory newPolicy) external;
+
   /**
    * @dev The PremiumsAccount is notified that the policy was resolved and issues the payout to the policyHolder.
    *
@@ -39,11 +55,7 @@ interface IPremiumsAccount {
    * @param policy The policy that was resolved
    * @param payout The amount that has to be transferred to `policyHolder`
    */
-  function policyResolvedWithPayout(
-    address policyHolder,
-    Policy.PolicyData memory policy,
-    uint256 payout
-  ) external;
+  function policyResolvedWithPayout(address policyHolder, Policy.PolicyData memory policy, uint256 payout) external;
 
   /**
    * @dev The PremiumsAccount is notified that the policy has expired, unlocks the SCR and earns the pure premium.

package/contracts/migration/LPManualWhitelistV20.sol

@@ -30,10 +30,7 @@ abstract contract LPManualWhitelistV20 is ILPWhitelist, PolicyPoolComponent {
     __PolicyPoolComponent_init();
   }
 
-  function whitelistAddress(address provider, bool whitelisted)
-    external
-    onlyComponentRole(LP_WHITELIST_ROLE)
-  {
+  function whitelistAddress(address provider, bool whitelisted) external onlyComponentRole(LP_WHITELIST_ROLE) {
     if (_whitelisted[provider] != whitelisted) {
       _whitelisted[provider] = whitelisted;
       emit LPWhitelisted(provider, whitelisted);
@@ -47,20 +44,11 @@ abstract contract LPManualWhitelistV20 is ILPWhitelist, PolicyPoolComponent {
     return super.supportsInterface(interfaceId) || interfaceId == type(ILPWhitelist).interfaceId;
   }
 
-  function acceptsDeposit(
-    IEToken,
-    address provider,
-    uint256
-  ) external view override returns (bool) {
+  function acceptsDeposit(IEToken, address provider, uint256) external view override returns (bool) {
     return _whitelisted[provider];
   }
 
-  function acceptsTransfer(
-    IEToken,
-    address,
-    address providerTo,
-    uint256
-  ) external view override returns (bool) {
+  function acceptsTransfer(IEToken, address, address providerTo, uint256) external view override returns (bool) {
     return _whitelisted[providerTo];
   }
 

package/contracts/migration/LPManualWhitelistV20Upgraded.sol

@@ -15,11 +15,7 @@ import {LPManualWhitelistV20} from "./LPManualWhitelistV20.sol";
 contract LPManualWhitelistV20Upgraded is LPManualWhitelistV20 {
   constructor(IPolicyPool policyPool_) LPManualWhitelistV20(policyPool_) {}
 
-  function acceptsWithdrawal(
-    IEToken etk,
-    address provider,
-    uint256 amount
-  ) external view override returns (bool) {
+  function acceptsWithdrawal(IEToken etk, address provider, uint256 amount) external view override returns (bool) {
     return this.acceptsDeposit(etk, provider, amount);
   }
 }

package/contracts/mocks/FixedRateVault.sol

@@ -33,12 +33,7 @@ contract FixedRateVault is ERC4626 {
   /**
    * @dev Deposit/mint common workflow.
    */
-  function _deposit(
-    address caller,
-    address receiver,
-    uint256 assets,
-    uint256 shares
-  ) internal virtual override {
+  function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual override {
     require(!_broken, "Vault is broken");
     _totalAssets.add(assets, _interestRate);
     super._deposit(caller, receiver, assets, shares);

package/contracts/mocks/InterfaceIdCalculator.sol

@@ -10,6 +10,7 @@ import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
 import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
 import {IEToken} from "../interfaces/IEToken.sol";
 import {IRiskModule} from "../interfaces/IRiskModule.sol";
+import {IPolicyHolder} from "../interfaces/IPolicyHolder.sol";
 import {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
 import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
 import {IAccessManager} from "../interfaces/IAccessManager.sol";
@@ -29,4 +30,5 @@ contract InterfaceIdCalculator {
   bytes4 public constant ILPWHITELIST_INTERFACEID = type(ILPWhitelist).interfaceId;
   bytes4 public constant IACCESSMANAGER_INTERFACEID = type(IAccessManager).interfaceId;
   bytes4 public constant IASSETMANAGER_INTERFACEID = type(IAssetManager).interfaceId;
+  bytes4 public constant IPOLICYHOLDER_INTERFACEID = type(IPolicyHolder).interfaceId;
 }

package/contracts/mocks/PolicyHolderMock.sol

@@ -20,12 +20,7 @@ contract PolicyHolderMock is IPolicyHolder {
     PolicyExpired
   }
 
-  event NotificationReceived(
-    NotificationKind kind,
-    uint256 policyId,
-    address operator,
-    address from
-  );
+  event NotificationReceived(NotificationKind kind, uint256 policyId, address operator, address from);
 
   constructor() {
     fail = false;
@@ -65,8 +60,7 @@ contract PolicyHolderMock is IPolicyHolder {
         revert(0, 0)
       }
     if (notImplemented) return false;
-    return
-      interfaceId == type(IPolicyHolder).interfaceId || interfaceId == type(IERC165).interfaceId;
+    return interfaceId == type(IPolicyHolder).interfaceId || interfaceId == type(IERC165).interfaceId;
   }
 
   function onERC721Received(
@@ -91,11 +85,7 @@ contract PolicyHolderMock is IPolicyHolder {
     return IERC721Receiver.onERC721Received.selector;
   }
 
-  function onPolicyExpired(
-    address operator,
-    address from,
-    uint256 policyId_
-  ) external override returns (bytes4) {
+  function onPolicyExpired(address operator, address from, uint256 policyId_) external override returns (bytes4) {
     if (fail)
       if (emptyRevert)
         assembly {

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -20,8 +20,6 @@ contract PolicyPoolComponentMock is IPolicyPoolComponent {
    * @dev See {IERC165-supportsInterface}.
    */
   function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
-    return
-      interfaceId == type(IERC165).interfaceId ||
-      interfaceId == type(IPolicyPoolComponent).interfaceId;
+    return interfaceId == type(IERC165).interfaceId || interfaceId == type(IPolicyPoolComponent).interfaceId;
   }
 }