@ensuro/core 1.2.5 → 2.0.0-beta1

package/contracts/TrustfulRiskModule.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.0;
 
-import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPool} from "./interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "./interfaces/IPremiumsAccount.sol";
 import {RiskModule} from "./RiskModule.sol";
 import {Policy} from "./Policy.sol";
 
@@ -19,35 +20,36 @@ contract TrustfulRiskModule is RiskModule {
 
   /// @custom:oz-upgrades-unsafe-allow constructor
   // solhint-disable-next-line no-empty-blocks
-  constructor(IPolicyPool policyPool_) RiskModule(policyPool_) {}
+  constructor(IPolicyPool policyPool_, IPremiumsAccount premiumsAccount_)
+    RiskModule(policyPool_, premiumsAccount_)
+  {} // solhint-disable-line no-empty-blocks
 
   /**
    * @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 premium that will go for Ensuro treasury (in ray)
-   * @param scrInterestRate_ cost of capital (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 ray)
+   * @param ensuroPpFee_ % of pure premium that will go for Ensuro treasury (in ray)
+   * @param srRoc_ return on capital paid to Senior LPs (annualized percentage - in ray)
+   * @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
    */
   function initialize(
     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_
   ) public initializer {
     __RiskModule_init(
       name_,
-      scrPercentage_,
-      ensuroFee_,
-      scrInterestRate_,
-      maxScrPerPolicy_,
-      scrLimit_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
       wallet_
     );
   }
@@ -59,13 +61,13 @@ contract TrustfulRiskModule is RiskModule {
     uint40 expiration,
     address customer,
     uint96 internalId
-  ) external onlyRole(PRICER_ROLE) returns (uint256) {
+  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
     return _newPolicy(payout, premium, lossProb, expiration, customer, internalId).id;
   }
 
   function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
     external
-    onlyRole(RESOLVER_ROLE)
+    onlyComponentRole(RESOLVER_ROLE)
     whenNotPaused
   {
     _policyPool.resolvePolicy(policy, payout);
@@ -73,7 +75,7 @@ contract TrustfulRiskModule is RiskModule {
 
   function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
     external
-    onlyRole(RESOLVER_ROLE)
+    onlyComponentRole(RESOLVER_ROLE)
     whenNotPaused
   {
     _policyPool.resolvePolicyFullPayout(policy, customerWon);

package/contracts/dependencies/ERC1967Proxy.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/*
+This is a workaround for:
+
+https://github.com/eth-brownie/brownie/issues/1581
+
+Which affects ethproto. The contract is just here for ethproto's
+sake and is not actually used by any contract.
+
+Once that bug is fixed (either in brownie or in ethproto) this
+file can be safely removed.
+
+*/
+
+import {ERC1967Proxy as ERC1967ProxyOriginal} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+abstract contract ERC1967Proxy is ERC1967ProxyOriginal {}

package/contracts/dependencies/IERC20Metadata.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/*
+This is a workaround for:
+
+https://github.com/eth-brownie/brownie/issues/1581
+
+Which affects ethproto. The contract is just here for ethproto's
+sake and is not actually used by any contract.
+
+Once that bug is fixed (either in brownie or in ethproto) this
+file can be safely removed.
+
+*/
+
+import {IERC20Metadata as IERC20MetadataOriginal} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IERC20Metadata is IERC20MetadataOriginal {}

package/contracts/interfaces/IEToken.sol

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @title IEToken interface
+ * @dev Interface for EToken smart contracts, these are the capital pools.
+ * @author Ensuro
+ */
+interface IEToken is IERC20 {
+  /**
+   * @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)
+   * @param value The amount locked
+   */
+  event SCRLocked(uint256 interestRate, uint256 value);
+
+  /**
+   * @dev Event emitted when the locked funds are unlocked and no longer used as solvency capital.
+   * @param interestRate The annualized interestRate that was paid for the capital (wad)
+   * @param value The amount unlocked
+   */
+  event SCRUnlocked(uint256 interestRate, uint256 value);
+
+  /**
+   * @dev Returns the amount of capital that's locked as solvency capital for active policies.
+   */
+  function scr() external view returns (uint256);
+
+  /**
+   * @dev Locks part of the liquidity of the EToken as solvency capital.
+   *
+   * Requirements:
+   * - Must be called by a _borrower_ previously added with `addBorrower`.
+   * - `scrAmount` <= `fundsAvailableToLock()`
+   *
+   * Events:
+   * - Emits {SCRLocked}
+   *
+   * @param scrAmount The amount to lock
+   * @param policyInterestRate The annualized interest rate (wad) to be paid for the `scrAmount`
+   */
+  function lockScr(uint256 scrAmount, uint256 policyInterestRate) external;
+
+  /**
+   * @dev Unlocks solvency capital previously locked with `lockScr`. The capital no longer needed as solvency.
+   *
+   * Requirements:
+   * - Must be called by a _borrower_ previously added with `addBorrower`.
+   * - `scrAmount` <= `scr()`
+   *
+   * Events:
+   * - Emits {SCRUnlocked}
+   *
+   * @param scrAmount The amount to unlock
+   * @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;
+
+  /**
+   * @dev Registers a deposit of liquidity in the pool. Called from the PolicyPool, assumes the amount has already been
+   * transferred. `amount` of eToken are minted and given to the provider in exchange of the liquidity provided.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   * - The amount was transferred
+   * - `utilizationRate()` after the deposit is >= `minUtilizationRate()`
+   *
+   * Events:
+   * - Emits {Transfer} with `from` = 0x0 and to = `provider`
+   *
+   * @param provider The address of the liquidity provider
+   * @param amount The amount deposited.
+   * @return The actual balance of the provider (TODO)
+   */
+  function deposit(address provider, uint256 amount) external returns (uint256);
+
+  /**
+   * @dev Withdraws an amount from an eToken. `withdrawn` eTokens are be burned and the user receives the same amount
+   * in `currency()`. If the asked `amount` can't be withdrawn, it withdraws as much as possible
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - Emits {Transfer} with `from` = `provider` and to = `0x0`
+   *
+   * @param provider The address of the liquidity provider
+   * @param amount The amount to withdraw. If `amount` == `type(uint256).max`, then tries to withdraw all the balance.
+   * @return withdrawn The actual amount that withdrawn. `withdrawn <= amount && withdrawn <= balanceOf(provider)`
+   */
+  function withdraw(address provider, uint256 amount) external returns (uint256 withdrawn);
+
+  /**
+   * @dev Returns the total amount that can be withdrawn
+   */
+  function totalWithdrawable() external view returns (uint256);
+
+  /**
+   * @dev Adds an authorized _borrower_ to the eToken. This _borrower_ will be allowed to lock/unlock funds and to take
+   * loans.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - Emits {PoolBorrowerAdded}
+   *
+   * @param borrower The address of the _borrower_, a PremiumsAccount that has this eToken as senior or junior eToken.
+   */
+  function addBorrower(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`.
+   *
+   * Requirements:
+   * - Must be called by a _borrower_ previously added with `addBorrower`.
+   *
+   * Events:
+   * - Emits {InternalLoan}
+   * - Emits {ERC20-Transfer} transferring `lent` to `receiver`
+   *
+   * @param amount The amount required
+   * @param receiver The received of the funds lent. This is usually the policyholder if the loan is used for a payout.
+   * @param fromAvailable If `true`, the funds that can be lent are only the available ones, i.e., excluding the funds
+   * locked as `scr()`. If `false`, all the `totalSupply()` is available to be lent.
+   * @return Returns the amount that wasn't able to fulfil. `amount - lent`
+   */
+  function internalLoan(
+    uint256 amount,
+    address receiver,
+    bool fromAvailable
+  ) external returns (uint256);
+
+  /**
+   * @dev Repays a loan taken with `internalLoan`.
+   *
+   * Requirements:
+   * - `msg.sender` approved the spending of `currency()` for at least `amount`
+
+   * Events:
+   * - Emits {InternalLoanRepaid}
+   * - Emits {ERC20-Transfer} transferring `amount` from `msg.sender` to `this`
+   *
+   * @param amount The amount to repaid, that will be transferred from `msg.sender` balance.
+   * @param onBehalfOf The address of the borrower that took the loan. Usually `onBehalfOf == msg.sender` but we keep it
+   * open because in some cases with might need someone else pays the debt.
+   */
+  function repayLoan(uint256 amount, address onBehalfOf) external;
+
+  /**
+   * @dev Returns the updated debt (principal + interest) of the `borrower`.
+   */
+  function getLoan(address borrower) external view returns (uint256);
+
+  /**
+   * @dev The annualized interest rate at which the `totalSupply()` grows
+   */
+  function tokenInterestRate() external view returns (uint256);
+
+  /**
+   * @dev The weighted average annualized interest rate paid by the currently locked `scr()`.
+   */
+  function scrInterestRate() external view returns (uint256);
+}

package/contracts/interfaces/IPolicyPool.sol

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+
+interface IPolicyPool {
+  /**
+   * @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
+   */
+  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
+   */
+  function config() external view returns (IPolicyPoolConfig);
+
+  /**
+   * @dev Reference to the {PolicyNFT} contract. This contract it's an ERC721 Token that handles the ownership of the
+   *      policies.
+   * @return The address of the PolicyNFT contract
+   */
+  function policyNFT() external view returns (address);
+
+  /**
+   * @dev 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`
+   * - `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
+   * (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 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,
+    uint96 internalId
+  ) external returns (uint256);
+
+  /**
+   * @dev Resolves a policy with a payout. Must be called from an active RiskModule
+   *
+   * Requirements:
+   * - `policy`: must be a Policy previously created with `newPolicy` (checked with `policy.hash()`) and not
+   *   resolved before and not expired (if payout > 0).
+   * - `payout`: must be less than equal to `policy.payout`.
+   *
+   * Events:
+   * - {PolicyPool-PolicyResolved}: with the payout
+   * - {ERC20-Transfer}: to the policyholder with the payout
+   *
+   * @param policy A policy previously created with `newPolicy`
+   * @param payout The amount to paid to the policyholder
+   */
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout) external;
+
+  /**
+   * @dev Resolves a policy with a payout that can be either 0 or the maximum payout of the policy
+   *
+   * Requirements:
+   * - `policy`: must be a Policy previously created with `newPolicy` (checked with `policy.hash()`) and not
+   *   resolved before and not expired (if customerWon).
+   *
+   * Events:
+   * - {PolicyPool-PolicyResolved}: with the payout
+   * - {ERC20-Transfer}: to the policyholder with the payout
+   *
+   * @param policy A policy previously created with `newPolicy`
+   * @param customerWon Indicated if the payout is zero or the maximum payout
+   */
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon) external;
+
+  /**
+   * @dev Resolves a policy with a payout 0, unlocking the solvency. Can be called by anyone, but only after
+   * `Policy.expiration`.
+   *
+   * Requirements:
+   * - `policy`: must be a Policy previously created with `newPolicy` (checked with `policy.hash()`) and not resolved
+   * before
+   * - Policy expired: `Policy.expiration` <= block.timestamp
+   *
+   * Events:
+   * - {PolicyPool-PolicyResolved}: with payout == 0
+   *
+   * @param policy A policy previously created with `newPolicy`
+   */
+  function expirePolicy(Policy.PolicyData calldata policy) external;
+
+  /**
+   * @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.
+   *
+   * Requirements:
+   * - `msg.sender` approved the spending of `currency()` for at least `amount`
+   * - `eToken` is an active eToken installed in the pool.
+   *
+   * Events:
+   * - {EToken-Transfer}: from 0x0 to `msg.sender`, reflects the eTokens minted.
+   * - {ERC20-Transfer}: from `msg.sender` to address(eToken)
+   *
+   * @param eToken The address of the eToken to which the user wants to provide liquidity
+   * @param amount The amount to deposit
+   */
+  function deposit(IEToken eToken, uint256 amount) external;
+
+  /**
+   * @dev Withdraws an amount from an eToken. Forwards the call to {EToken-withdraw}.
+   * `amount` of eTokens will be burned and the user will receive the same amount in `currency()`.
+   *
+   * Requirements:
+   * - `eToken` is an active (or deprecated) eToken installed in the pool.
+   *
+   * Events:
+   * - {EToken-Transfer}: from `msg.sender` to `0x0`, reflects the eTokens burned.
+   * - {ERC20-Transfer}: from address(eToken) to `msg.sender`
+   *
+   * @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
+   *               as much as it can, but doesn't fails.
+   * @return Returns the actual amount withdrawn.
+   */
+  function withdraw(IEToken eToken, uint256 amount) external returns (uint256);
+}

package/{interfaces → contracts/interfaces}/IPolicyPoolConfig.sol

@@ -2,11 +2,8 @@
 pragma solidity ^0.8.0;
 
 import {IAccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
-import {IAssetManager} from "./IAssetManager.sol";
-import {IInsolvencyHook} from "./IInsolvencyHook.sol";
 import {ILPWhitelist} from "./ILPWhitelist.sol";
 import {IRiskModule} from "./IRiskModule.sol";
-import {IExchange} from "./IExchange.sol";
 
 /**
  * @title IPolicyPoolAccess - Interface for the contract that handles roles for the PolicyPool and components
@@ -22,20 +19,35 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
     setLPWhitelist, // Changes PolicyPool Liquidity Providers Whitelist
     addRiskModule,
     removeRiskModule,
+    cfgFiller1, // Reserve space for future PolicyPoolConfig actions
+    cfgFiller2, // Reserve space for future PolicyPoolConfig actions
+    cfgFiller3, // Reserve space for future PolicyPoolConfig actions
+    cfgFiller4, // Reserve space for future PolicyPoolConfig actions
     // RiskModule Governance Actions
-    setScrPercentage,
     setMoc,
-    setScrInterestRate,
-    setEnsuroFee,
-    setMaxScrPerPolicy,
-    setScrLimit,
-    setSharedCoverageMinPercentage,
-    setSharedCoveragePercentage,
+    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
     setLiquidityRequirement,
+    setMinUtilizationRate,
     setMaxUtilizationRate,
-    setPoolLoanInterestRate,
+    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
     // AssetManager Governance Actions
     setLiquidityMin,
     setLiquidityMiddle,
@@ -44,9 +56,8 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
     setClaimRewardsMin,
     setReinvestRewardsMin,
     setMaxSlippage,
-    setAcceptAllRMs, // EToken Governance action  - value == boolean
-    setAcceptException, // EToken Governance action - value == (!isException << 255)|address
-    setExchange, // Changes exchange helper contract
+    setPriceOracle, // Changes exchange's PriceOracle
+    setSwapRouter, // Changes exchange's SwapRouter
     last
   }
 
@@ -61,6 +72,12 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
 
   function checkRole(bytes32 role, address account) external view;
 
+  function checkComponentRole(
+    address component,
+    bytes32 role,
+    address account
+  ) external view;
+
   function checkRole2(
     bytes32 role1,
     bytes32 role2,
@@ -69,14 +86,8 @@ interface IPolicyPoolConfig is IAccessControlUpgradeable {
 
   function connect() external;
 
-  function assetManager() external view returns (IAssetManager);
-
-  function insolvencyHook() external view returns (IInsolvencyHook);
-
   function lpWhitelist() external view returns (ILPWhitelist);
 
-  function exchange() external view returns (IExchange);
-
   function treasury() external view returns (address);
 
   function checkAcceptsNewPolicy(IRiskModule riskModule) external view;

package/contracts/interfaces/IPremiumsAccount.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IEToken} from "./IEToken.sol";
+import {Policy} from "../Policy.sol";
+
+/**
+ * @title IPremiumsAccount interface
+ * @dev Interface for Premiums Account contracts.
+ * @author Ensuro
+ */
+interface IPremiumsAccount {
+  /**
+   * @dev Adds a policy to the PremiumsAccount. Stores the pure premiums and locks the aditional funds from junior and
+   * senior eTokens.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - {EToken-SCRLocked}
+   *
+   * @param policy The policy to add (created in this transaction)
+   */
+  function policyCreated(Policy.PolicyData memory policy) external;
+
+  /**
+   * @dev The PremiumsAccount is notified that the policy was resolved and issues the payout to the policyHolder.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - {ERC20-Transfer}: `to == policyHolder`, `amount == payout`
+   * - {EToken-InternalLoan}: optional, if a loan needs to be taken
+   * - {EToken-SCRUnlocked}
+   *
+   * @param policyHolder The one that will receive the payout
+   * @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;
+
+  /**
+   * @dev The PremiumsAccount is notified that the policy has expired, unlocks the SCR and earns the pure premium.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * Events:
+   * - {ERC20-Transfer}: `to == policyHolder`, `amount == payout`
+   * - {EToken-InternalLoanRepaid}: optional, if a loan was taken before
+   *
+   * @param policy The policy that has expired
+   */
+  function policyExpired(Policy.PolicyData memory policy) external;
+
+  /**
+   * @dev The senior eToken, the secondary source of solvency, used if the premiums account is exhausted and junior too
+   */
+  function seniorEtk() external view returns (IEToken);
+
+  /**
+   * @dev The junior eToken, the primary source of solvency, used if the premiums account is exhausted.
+   */
+  function juniorEtk() external view returns (IEToken);
+}

package/contracts/interfaces/IRiskModule.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPremiumsAccount} from "./IPremiumsAccount.sol";
+
+/**
+ * @title IRiskModule interface
+ * @dev Interface for RiskModule smart contracts. Gives access to RiskModule configuration parameters
+ * @author Ensuro
+ */
+interface IRiskModule {
+  enum Parameter {
+    moc,
+    jrCollRatio,
+    collRatio,
+    ensuroPpFee,
+    ensuroCocFee,
+    jrRoc,
+    srRoc,
+    maxPayoutPerPolicy,
+    exposureLimit,
+    maxDuration
+  }
+
+  struct Params {
+    uint256 moc;
+    uint256 jrCollRatio;
+    uint256 collRatio;
+    uint256 ensuroPpFee;
+    uint256 ensuroCocFee;
+    uint256 jrRoc;
+    uint256 srRoc;
+  }
+
+  function name() external view returns (string memory);
+
+  function params() external view returns (Params memory);
+
+  function maxPayoutPerPolicy() external view returns (uint256);
+
+  function exposureLimit() external view returns (uint256);
+
+  function maxDuration() external view returns (uint256);
+
+  function activeExposure() external view returns (uint256);
+
+  function wallet() external view returns (address);
+
+  /**
+   * @dev Called when a policy expires or is resolved to update the exposure.
+   *
+   * Requirements:
+   * - Must be called by `policyPool()`
+   *
+   * @param payout The exposure (maximum payout) of the policy
+   */
+  function releaseExposure(uint256 payout) external;
+
+  function premiumsAccount() external view returns (IPremiumsAccount);
+}