@ensuro/core 2.0.0-beta1 → 2.0.0-beta11

package/contracts/interfaces/IAccessManager.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IAccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+
+/**
+ * @title IAccessManager - Interface for the contract that handles roles for the PolicyPool and components
+ * @dev Interface for the contract that handles roles for the PolicyPool and components
+ * @author Ensuro
+ */
+interface IAccessManager is IAccessControlUpgradeable {
+  /**
+   * @dev Enum with the different governance actions supported in the protocol.
+   *      It's good to keep actions of the same component consecutive, parts of the code relay on that,
+   *      so we put some fillers in case new actions are added.
+   */
+  enum GovernanceActions {
+    none,
+    setTreasury, // Changes PolicyPool treasury address
+    setAssetManager, // Change in the asset manager strategy of a reserve
+    setAssetManagerForced, // Change in the asset manager strategy of a reserve, forced (deinvest failed)
+    ppFiller1, // Reserve space for future PolicyPool or AccessManager actions
+    ppFiller2, // Reserve space for future PolicyPool or AccessManager actions
+    ppFiller3, // Reserve space for future PolicyPool or AccessManager actions
+    ppFiller4, // Reserve space for future PolicyPool or AccessManager actions
+    // RiskModule Governance Actions
+    setMoc,
+    setJrCollRatio,
+    setCollRatio,
+    setEnsuroPpFee,
+    setEnsuroCocFee,
+    setJrRoc,
+    setSrRoc,
+    setMaxPayoutPerPolicy,
+    setExposureLimit,
+    setMaxDuration,
+    setWallet,
+    rmFiller1, // Reserve space for future RM actions
+    rmFiller2, // Reserve space for future RM actions
+    rmFiller3, // Reserve space for future RM actions
+    rmFiller4, // Reserve space for future RM actions
+    // EToken Governance Actions
+    setLPWhitelist, // Changes EToken Liquidity Providers Whitelist
+    setLiquidityRequirement,
+    setMinUtilizationRate,
+    setMaxUtilizationRate,
+    setInternalLoanInterestRate,
+    etkFiller1, // Reserve space for future EToken actions
+    etkFiller2, // Reserve space for future EToken actions
+    etkFiller3, // Reserve space for future EToken actions
+    etkFiller4, // Reserve space for future EToken actions
+    // PremiumsAccount Governance Actions
+    setDeficitRatio,
+    setDeficitRatioWithAdjustment,
+    paFiller1,
+    paFiller2,
+    paFiller3,
+    paFiller4,
+    // AssetManager Governance Actions
+    setLiquidityMin,
+    setLiquidityMiddle,
+    setLiquidityMax,
+    amFiller1, // Reserve space for future Asset Manager actions
+    amFiller2, // Reserve space for future Asset Manager actions
+    amFiller3, // Reserve space for future Asset Manager actions
+    amFiller4, // Reserve space for future Asset Manager actions
+    last
+  }
+
+  /**
+   * @dev Gets a role identifier mixing the hash of the global role and the address of the component
+   *
+   * @param component The component where this role will apply
+   * @param role A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @return A new role, mixing (XOR) the component address and the role.
+   */
+  function getComponentRole(address component, bytes32 role) external view returns (bytes32);
+
+  /**
+   * @dev Tells if a user has been granted a given role for a component
+   *
+   * @param component The component where this role will apply
+   * @param role A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @param account The user address for who we want to verify the permission
+   * @param alsoGlobal If true, it will return if the users has either the component role, or the role itself.
+   *                   If false, only the component role is accepted
+   * @return Whether the user has or not any of the roles
+   */
+  function hasComponentRole(
+    address component,
+    bytes32 role,
+    address account,
+    bool alsoGlobal
+  ) external view returns (bool);
+
+  /**
+   * @dev Checks if a user has been granted a given role and reverts if it doesn't
+   *
+   * @param role A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @param account The user address for who we want to verify the permission
+   */
+  function checkRole(bytes32 role, address account) external view;
+
+  /**
+   * @dev Checks if a user has been granted any of the two roles specified and reverts if it doesn't
+   *
+   * @param role1 A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @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;
+
+  /**
+   * @dev Checks if a user has been granted a given component role and reverts if it doesn't
+   *
+   * @param role A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @param account The user address for who we want to verify the permission
+   * @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;
+
+  /**
+   * @dev Checks if a user has been granted any of the two component roles specified and reverts if it doesn't
+   *
+   * @param role1 A role such as `keccak256("LEVEL1_ROLE")` that's global
+   * @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
+   * @param alsoGlobal If true, it will accept not only the component roles, but also the global ones.
+   *                   If false, only the component roles are accepted
+   */
+  function checkComponentRole2(
+    address component,
+    bytes32 role1,
+    bytes32 role2,
+    address account,
+    bool alsoGlobal
+  ) external view;
+}

package/contracts/interfaces/IAssetManager.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/**
+ * @title IAssetManager - Interface of the asset management strategy that's plugged into the reserves
+ * @dev The asset manager is a contract that's plugged and called with `delegatecall` (operates in the context of the
+ *      reserve - see {Reserve}). The asset manager contract applies a strategy to invest the reserve funds and
+ *      get additional yields.
+ *
+ *      All implementations of this contract should use the Diamond Storage pattern to avoid overwriting the calling contract's state.
+ *      See https://eips.ethereum.org/EIPS/eip-2535#storage
+ * @author Ensuro
+ */
+interface IAssetManager is IERC165 {
+  /**
+   * @dev Event emitted when funds are removed from Reserve liquidity and invested in the investment strategy,
+   * @param amount The amount invested
+   */
+  event MoneyInvested(uint256 amount);
+
+  /**
+   * @dev Event emitted when funds are deinvested from the investment strategy and returned to the reserve as liquid
+   * funds.
+   *
+   * @param amount The amount de-invested
+   */
+  event MoneyDeinvested(uint256 amount);
+
+  /**
+   * @dev Event emitted when investment yields are accounted in the reserve
+   *
+   * @param earnings The amount of earnings generated since last record. It's positive in the case of earnings or
+   * negative when there are losses.
+   */
+  event EarningsRecorded(int256 earnings);
+
+  /**
+   * @dev Function called when an asset manager is plugged into a reserve. Useful for initialization tasks
+   */
+  function connect() external;
+
+  /**
+   * @dev Gives the opportunity to the asset manager to rebalance the funds between those that are kept liquid in the
+   * reserve balance and those that are invested. Called with delegatecall by the reserve from the external function
+   * rebalance (see {Reserve-rebalance}).
+   *
+   * Events:
+   * - Emits {MoneyInvested} or {MoneyDeinvested}
+   */
+  function rebalance() external;
+
+  /**
+   * @dev Gives the opportunity to the asset manager to rebalance the funds between those that are kept liquid in the
+   * reserve balance and those that are invested. Called with delegatecall by the reserve from the external function
+   * rebalance (see {Reserve-rebalance}).
+   *
+   * Events:
+   * - Emits {MoneyInvested} or {MoneyDeinvested}
+   */
+  function recordEarnings() external returns (int256);
+
+  /**
+   * @dev Refills the reserve balance with enough money to do a payment. Called from the reserve when a payment needs
+   * to be made and there's no enough liquid balance (`currency().balanceOf(reserve) < paymentAmount`)
+   *
+   * Events:
+   * - Emits {MoneyDeinvested} with the amount transferred to the liquid balance.
+   *
+   * @param paymentAmount The total amount of the payment that needs to be made. If this function is called, it's
+   * because paymentAmount > balanceOf(reserve). The minimum amount that needs to be transferred to the reserve is
+   * `paymentAmount - balanceOf(reserve)`, but it can transfer more.
+   * @return Returns the actual amount transferred
+   */
+  function refillWallet(uint256 paymentAmount) external returns (uint256);
+
+  /**
+   * @dev Deinvests all the funds transfer all the assets to the liquid balance. Called from the reserve when the asset
+   * manager is unplugged.
+   *
+   * Events:
+   * - Emits {MoneyDeinvested} with the amount transferred to the liquid balance.
+   * - Emits {EarningsRecorded} with the amount of earnings since earnings were recorded last time.
+   *
+   * @return Returns the earnings or losses (negative) since last time earnings were recorded.
+   */
+  function deinvestAll() external returns (int256);
+}

package/contracts/interfaces/IEToken.sol

@@ -9,6 +9,16 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  * @author Ensuro
  */
 interface IEToken is IERC20 {
+  /**
+   * @dev Enum of the different parameters that are configurable in an EToken.
+   */
+  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)
@@ -77,7 +87,7 @@ interface IEToken is IERC20 {
    *
    * @param provider The address of the liquidity provider
    * @param amount The amount deposited.
-   * @return The actual balance of the provider (TODO)
+   * @return The actual balance of the provider
    */
   function deposit(address provider, uint256 amount) external returns (uint256);
 
@@ -110,12 +120,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/ILPWhitelist.sol

@@ -8,12 +8,29 @@ import {IEToken} from "./IEToken.sol";
  * @author Ensuro
  */
 interface ILPWhitelist {
+  /**
+   * @dev Indicates whether or not a liquidity provider can do a deposit in an eToken.
+   *
+   * @param etoken The eToken (see {EToken}) where the provider wants to deposit money.
+   * @param provider The address of the liquidity provider (user) that wants to deposit
+   * @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);
 
+  /**
+   * @dev Indicates whether or not the eTokens can be transferred from `providerFrom` to `providerTo`
+   *
+   * @param etoken The eToken (see {EToken}) that the LPs have the intention to transfer.
+   * @param providerFrom The current owner of the tokens
+   * @param providerTo The destination of the tokens if the transfer is accepted
+   * @param amount The amount of tokens to be transferred
+   * @return true if the transfer operation is accepted, false if not.
+   */
   function acceptsTransfer(
     IEToken etoken,
     address providerFrom,

package/contracts/interfaces/IPolicyPool.sol

@@ -4,7 +4,7 @@ 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 {IPolicyPoolConfig} from "./IPolicyPoolConfig.sol";
+import {IAccessManager} from "./IAccessManager.sol";
 
 interface IPolicyPool {
   /**
@@ -14,40 +14,40 @@ interface IPolicyPool {
   function currency() external view returns (IERC20Metadata);
 
   /**
-   * @dev Reference to the {PolicyPoolConfig} contract, this contract manages the access controls and installed risk
-   *      modules.
-   * @return The address of the PolicyPoolConfig contract
+   * @dev Reference to the {AccessManager} contract, this contract manages the access controls.
+   * @return The address of the AccessManager contract
    */
-  function config() external view returns (IPolicyPoolConfig);
+  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
+   * @dev Address of the treasury, that receives protocol fees.
+   * @return The address of the treasury
    */
-  function policyNFT() external view returns (address);
+  function treasury() external view returns (address);
 
   /**
    * @dev Creates a new Policy. Must be called from an active RiskModule
    *
    * 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);
 
@@ -100,6 +100,13 @@ interface IPolicyPool {
    */
   function expirePolicy(Policy.PolicyData calldata policy) external;
 
+  /**
+   * @dev Returns whether or not a policy is active
+   * @param policyId The id of the policy we are querying
+   * @return Returns true if a policy with that id was created and wasn't yet resolved or expired, or false otherwise.
+   */
+  function isActive(uint256 policyId) external view returns (bool);
+
   /**
    * @dev Deposits liquidity into an eToken. Forwards the call to {EToken-deposit}, after transferring the funds.
    * The user will receive etokens for the same amount deposited.
@@ -130,7 +137,7 @@ interface IPolicyPool {
    *
    * @param eToken The address of the eToken from where the user wants to withdraw liquidity
    * @param amount The amount to withdraw. If equal to type(uint256).max, means full withdrawal.
-   *               If the balance is not enought or can't be withdrawn (locked as SCR), it withdraws
+   *               If the balance is not enough or can't be withdrawn (locked as SCR), it withdraws
    *               as much as it can, but doesn't fails.
    * @return Returns the actual amount withdrawn.
    */

package/contracts/interfaces/IPolicyPoolComponent.sol

@@ -2,12 +2,16 @@
 pragma solidity ^0.8.0;
 
 import {IPolicyPool} from "./IPolicyPool.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /**
  * @title IPolicyPoolComponent interface
  * @dev Interface for Contracts linked (owned) by a PolicyPool. Useful to avoid cyclic dependencies
  * @author Ensuro
  */
-interface IPolicyPoolComponent {
+interface IPolicyPoolComponent is IERC165 {
+  /**
+   * @dev Returns the address of the PolicyPool (see {PolicyPool}) where this component belongs.
+   */
   function policyPool() external view returns (IPolicyPool);
 }

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);
 }

package/contracts/interfaces/IRiskModule.sol

@@ -9,6 +9,9 @@ import {IPremiumsAccount} from "./IPremiumsAccount.sol";
  * @author Ensuro
  */
 interface IRiskModule {
+  /**
+   * @dev Enum with the different parameters of the risk module, used in {RiskModule-setParam}.
+   */
   enum Parameter {
     moc,
     jrCollRatio,
@@ -22,28 +25,85 @@ interface IRiskModule {
     maxDuration
   }
 
+  /**
+   * Struct of the parameters of the risk module that are used to calculate the different Policy fields (see
+   * {Policy-PolicyData}.
+   */
   struct Params {
+    /**
+     * @dev MoC (Margin of Conservativism) is a factor that multiplies the lossProb to increase or decrease the pure
+     * premium.
+     */
     uint256 moc;
+    /**
+     * @dev Junior Collateralization Ratio is the percentage of policy exposure (payout) that will be covered with the
+     * purePremium and the Junior EToken
+     */
     uint256 jrCollRatio;
+    /**
+     * @dev Collateralization Ratio is the percentage of policy exposure (payout) that will be covered by the
+     * purePremium and the Junior and Senior EToken. Usually is calculated as the relation between VAR99.5% and VAR100
+     * (full collateralization).
+     */
     uint256 collRatio;
+    /**
+     * @dev Ensuro PurePremium Fee is the percentage that will be multiplied by the pure premium to obtain the part of
+     * the Ensuro Fee that's proportional to the pure premium.
+     */
     uint256 ensuroPpFee;
+    /**
+     * @dev Ensuro Cost of Capital Fee is the percentage that will be multiplied by the cost of capital (CoC) to
+     * obtain the part of the Ensuro Fee that's proportional to the CoC.
+     */
     uint256 ensuroCocFee;
+    /**
+     * @dev Junior Return on Capital is the annualized interest rate that's charged for the capital locked in the Junior
+     * EToken.
+     */
     uint256 jrRoc;
+    /**
+     * @dev Senior Return on Capital is the annualized interest rate that's charged for the capital locked in the Senior
+     * EToken.
+     */
     uint256 srRoc;
   }
 
+  /**
+   * @dev A readable name of this risk module. Never changes.
+   */
   function name() external view returns (string memory);
 
+  /**
+   * @dev Returns different parameters of the risk module (see {Params})
+   */
   function params() external view returns (Params memory);
 
-  function maxPayoutPerPolicy() external view returns (uint256);
-
-  function exposureLimit() external view returns (uint256);
-
+  /**
+   * @dev Returns the maximum duration (in hours) of the policies of this risk module.
+   *      The `expiration` of the policies has to be `<= (block.timestamp + 3600 * maxDuration())`
+   */
   function maxDuration() external view returns (uint256);
 
+  /**
+   * @dev Returns the maximum payout accepted for new policies.
+   */
+  function maxPayoutPerPolicy() external view returns (uint256);
+
+  /**
+   * @dev Returns sum of the (maximum) payout of the active policies of this risk module, i.e. the maximum possible
+   * amount of money that's exposed for this risk module.
+   */
   function activeExposure() external view returns (uint256);
 
+  /**
+   * @dev Returns maximum exposure (sum of the (maximum) payout of the active policies) of this risk module.
+   * `activeExposure() <= exposureLimit()` always
+   */
+  function exposureLimit() external view returns (uint256);
+
+  /**
+   * @dev Returns the address of the partner that receives the partnerCommission
+   */
   function wallet() external view returns (address);
 
   /**
@@ -56,5 +116,8 @@ interface IRiskModule {
    */
   function releaseExposure(uint256 payout) external;
 
+  /**
+   * @dev Returns the {PremiumsAccount} where the premiums of this risk module are collected. Never changes.
+   */
   function premiumsAccount() external view returns (IPremiumsAccount);
 }

package/contracts/mocks/FixedRateVault.sol

@@ -0,0 +1,85 @@
+//SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC4626} from "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IMintableERC20} from "./IMintableERC20.sol";
+import {TimeScaled} from "../TimeScaled.sol";
+
+contract FixedRateVault is ERC4626 {
+  using TimeScaled for TimeScaled.ScaledAmount;
+
+  uint256 internal _interestRate;
+  TimeScaled.ScaledAmount internal _totalAssets;
+  bool internal _broken;
+
+  constructor(
+    string memory name_,
+    string memory symbol_,
+    IERC20Metadata asset_,
+    uint256 interestRate_
+  ) ERC20(name_, symbol_) ERC4626(asset_) {
+    _interestRate = interestRate_;
+    _totalAssets.init();
+  }
+
+  /** @dev See {IERC4262-totalAssets}. */
+  function totalAssets() public view virtual override returns (uint256) {
+    require(!_broken, "Vault is broken");
+    return _totalAssets.getScaledAmount(_interestRate);
+  }
+
+  /**
+   * @dev Deposit/mint common workflow.
+   */
+  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);
+  }
+
+  /**
+   * @dev Withdraw/redeem common workflow.
+   */
+  function _withdraw(
+    address caller,
+    address receiver,
+    address owner,
+    uint256 assets,
+    uint256 shares
+  ) internal virtual override {
+    require(!_broken, "Vault is broken");
+    _totalAssets.sub(assets, _interestRate);
+    uint256 balance = IERC20Metadata(asset()).balanceOf(address(this));
+    if (balance < assets) {
+      // Here comes the magic! Free money!
+      IMintableERC20(asset()).mint(address(this), assets - balance);
+    }
+    super._withdraw(caller, receiver, owner, assets, shares);
+  }
+
+  /*
+   * @dev Adds or remove assets not generated by deposits/withdraw - For testing discrete earnings/losses
+   */
+  function discreteEarning(int256 assets) external {
+    if (assets > 0) {
+      _totalAssets.add(uint256(assets), _interestRate);
+    } else {
+      _totalAssets.sub(uint256(-assets), _interestRate);
+    }
+  }
+
+  function setBroken(bool broken_) external {
+    _broken = broken_;
+  }
+
+  function broken() external view returns (bool) {
+    return _broken;
+  }
+}

package/contracts/mocks/InterfaceIdCalculator.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
+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 {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
+import {ILPWhitelist} from "../interfaces/ILPWhitelist.sol";
+import {IAccessManager} from "../interfaces/IAccessManager.sol";
+import {IAssetManager} from "../interfaces/IAssetManager.sol";
+
+contract InterfaceIdCalculator {
+  bytes4 public constant IERC165_INTERFACEID = type(IERC165).interfaceId;
+  bytes4 public constant IERC20_INTERFACEID = type(IERC20).interfaceId;
+  bytes4 public constant IERC20METADATA_INTERFACEID = type(IERC20Metadata).interfaceId;
+  bytes4 public constant IERC721_INTERFACEID = type(IERC721).interfaceId;
+  bytes4 public constant IACCESSCONTROL_INTERFACEID = type(IAccessControl).interfaceId;
+  bytes4 public constant IPOLICYPOOL_INTERFACEID = type(IPolicyPool).interfaceId;
+  bytes4 public constant IPOLICYPOOLCOMPONENT_INTERFACEID = type(IPolicyPoolComponent).interfaceId;
+  bytes4 public constant IETOKEN_INTERFACEID = type(IEToken).interfaceId;
+  bytes4 public constant IRISKMODULE_INTERFACEID = type(IRiskModule).interfaceId;
+  bytes4 public constant IPREMIUMSACCOUNT_INTERFACEID = type(IPremiumsAccount).interfaceId;
+  bytes4 public constant ILPWHITELIST_INTERFACEID = type(ILPWhitelist).interfaceId;
+  bytes4 public constant IACCESSMANAGER_INTERFACEID = type(IAccessManager).interfaceId;
+  bytes4 public constant IASSETMANAGER_INTERFACEID = type(IAssetManager).interfaceId;
+}