@ensuro/core 1.2.7 → 2.0.0-beta10

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,84 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @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.
+ * @author Ensuro
+ */
+interface IAssetManager {
+  /**
+   * @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 enought money to do a payment. Called from the reserve when a payment needs
+   * to be made and there's no enought 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

@@ -0,0 +1,195 @@
+// 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 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)
+   * @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
+   */
+  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 {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`.
+   *
+   * 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/ILPWhitelist.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IEToken} from "./IEToken.sol";
+
+/**
+ * @title ILPWhitelist - Interface that handles the whitelisting of Liquidity Providers
+ * @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,
+    address providerTo,
+    uint256 amount
+  ) external view returns (bool);
+}

package/contracts/interfaces/IPolicyPool.sol

@@ -0,0 +1,145 @@
+// 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 {IAccessManager} from "./IAccessManager.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 {AccessManager} contract, this contract manages the access controls.
+   * @return The address of the AccessManager contract
+   */
+  function access() external view returns (IAccessManager);
+
+  /**
+   * @dev Address of the treasury, that receives protocol fees.
+   * @return The address of the treasury
+   */
+  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
+   * - `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 caller address to the different receivers of the premium
+   * (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 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 policyHolder,
+    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 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.
+   *
+   * 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}/IPolicyPoolComponent.sol

@@ -9,5 +9,8 @@ import {IPolicyPool} from "./IPolicyPool.sol";
  * @author Ensuro
  */
 interface IPolicyPoolComponent {
+  /**
+   * @dev Returns the address of the PolicyPool (see {PolicyPool}) where this component belongs.
+   */
   function policyPool() external view returns (IPolicyPool);
 }