@ensuro/core 1.2.7 → 2.0.0-beta10

package/contracts/interfaces/IPremiumsAccount.sol

@@ -0,0 +1,76 @@
+// 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);
+
+  /**
+   * @dev The total amount of premiums hold by this PremiumsAccount
+   */
+  function purePremiums() external view returns (uint256);
+}

package/contracts/interfaces/IRiskModule.sol

@@ -0,0 +1,123 @@
+// 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 {
+  /**
+   * @dev Enum with the different parameters of the risk module, used in {RiskModule-setParam}.
+   */
+  enum Parameter {
+    moc,
+    jrCollRatio,
+    collRatio,
+    ensuroPpFee,
+    ensuroCocFee,
+    jrRoc,
+    srRoc,
+    maxPayoutPerPolicy,
+    exposureLimit,
+    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);
+
+  /**
+   * @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);
+
+  /**
+   * @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;
+
+  /**
+   * @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/ForwardProxy.sol

@@ -0,0 +1,66 @@
+//SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+import {Proxy} from "@openzeppelin/contracts/proxy/Proxy.sol";
+
+/**
+ * @dev This contract provides a fallback function that forwards all calls to another contract using the EVM
+ * instruction `call`.
+ *
+ * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
+ * different contract through the {_delegate} function.
+ *
+ * The success and return data of the delegated call will be returned back to the caller of the proxy.
+ */
+contract ForwardProxy is Proxy {
+  address internal _forwardTo;
+
+  constructor(address forwardTo) {
+    _forwardTo = forwardTo;
+  }
+
+  /**
+   * @dev Delegates the current call to `implementation`.
+   *
+   * This function does not return to its internall call site, it will return directly to the external caller.
+   */
+  function _delegate(address implementation) internal virtual override {
+    // solhint-disable-next-line no-inline-assembly
+    assembly {
+      // Copy msg.data. We take full control of memory in this inline assembly
+      // block because it will not return to Solidity code. We overwrite the
+      // Solidity scratch pad at memory position 0.
+      calldatacopy(0, 0, calldatasize())
+
+      // Call the implementation.
+      // out and outsize are 0 because we don't know the size yet.
+      // let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+      let result := call(gas(), implementation, 0, 0, calldatasize(), 0, 0)
+
+      // Copy the returned data.
+      returndatacopy(0, 0, returndatasize())
+
+      switch result
+      // delegatecall returns 0 on error.
+      case 0 {
+        revert(0, returndatasize())
+      }
+      default {
+        return(0, returndatasize())
+      }
+    }
+  }
+
+  /**
+   * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
+   * and {_fallback} should delegate.
+   */
+  function _implementation() internal view virtual override returns (address) {
+    return _forwardTo;
+  }
+
+  function setForwardTo(address forwardTo) external {
+    _forwardTo = forwardTo;
+  }
+}

package/contracts/mocks/IMintableERC20.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title IMintableERC20 interface
+ * @dev Interface for mintable / burnable ERC20 - for testing
+ * @author Ensuro
+ */
+interface IMintableERC20 {
+  function mint(address recipient, uint256 amount) external;
+
+  function burn(address recipient, uint256 amount) external;
+}

package/contracts/mocks/PolicyHolderMock.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyHolder} from "../interfaces/IPolicyHolder.sol";
+import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+
+contract PolicyHolderMock is IPolicyHolder {
+  uint256 public policyId;
+  uint256 public payout;
+  bool public fail;
+  bool public notImplemented;
+
+  event NotificationReceived(uint256 kind, uint256 policyId, address operator, address from);
+
+  constructor(bool fail_) {
+    fail = fail_;
+    notImplemented = false;
+    payout = type(uint256).max;
+  }
+
+  function setFail(bool fail_) external {
+    fail = fail_;
+  }
+
+  function setNotImplemented(bool notImplemented_) external {
+    notImplemented = notImplemented_;
+  }
+
+  function onERC721Received(
+    address operator,
+    address from,
+    uint256 policyId_,
+    bytes calldata
+  ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
+    if (fail) revert("onERC721Received: They told me I have to fail");
+    policyId = policyId_;
+    emit NotificationReceived(0, policyId_, operator, from);
+    return IERC721Receiver.onERC721Received.selector;
+  }
+
+  function onPolicyExpired(
+    address operator,
+    address from,
+    uint256 policyId_
+  ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
+    if (fail) revert("onPolicyExpired: They told me I have to fail");
+    policyId = policyId_;
+    payout = 0;
+    emit NotificationReceived(1, policyId_, operator, from);
+    return IPolicyHolder.onPolicyExpired.selector;
+  }
+
+  /**
+   * @dev Whenever an Policy is resolved with payout > 0, this function is called
+   *
+   * It must return its Solidity selector to confirm the payout.
+   * If interface is not implemented by the recipient, it will be ignored and the payout will be successful.
+   * If any other value is returned or it reverts, the policy resolution / payout will be reverted.
+   *
+   * The selector can be obtained in Solidity with `IPolicyPool.onPayoutReceived.selector`.
+   */
+  function onPayoutReceived(
+    address operator,
+    address from,
+    uint256 policyId_,
+    uint256 amount
+  ) external override returns (bytes4) {
+    if (notImplemented)
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        revert(0, 0)
+      }
+    if (fail) revert("onPayoutReceived: They told me I have to fail");
+    policyId = policyId_;
+    payout = amount;
+    emit NotificationReceived(2, policyId_, operator, from);
+    return IPolicyHolder.onPayoutReceived.selector;
+  }
+}

package/contracts/mocks/PolicyPoolComponentMock.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPolicyPoolComponent} from "../interfaces/IPolicyPoolComponent.sol";
+
+contract PolicyPoolComponentMock is IPolicyPoolComponent {
+  IPolicyPool internal immutable _policyPool;
+
+  constructor(IPolicyPool policyPool_) {
+    _policyPool = policyPool_;
+  }
+
+  function policyPool() external view override returns (IPolicyPool) {
+    return _policyPool;
+  }
+}

package/contracts/mocks/PolicyPoolMock.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IRiskModule} from "../interfaces/IRiskModule.sol";
+import {IEToken} from "../interfaces/IEToken.sol";
+import {IAccessManager} from "../interfaces/IAccessManager.sol";
+import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import {Policy} from "../Policy.sol";
+import {ForwardProxy} from "./ForwardProxy.sol";
+
+contract PolicyPoolMock is IPolicyPool {
+  using Policy for Policy.PolicyData;
+
+  uint256 public constant MAX_INT =
+    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+
+  IERC20Metadata internal _currency;
+  IAccessManager internal _access;
+
+  mapping(uint256 => Policy.PolicyData) internal policies;
+  mapping(uint256 => bytes32) internal policyHashes;
+
+  event NewPolicy(IRiskModule indexed riskModule, Policy.PolicyData policy);
+  event PolicyResolved(IRiskModule indexed riskModule, uint256 indexed policyId, uint256 payout);
+
+  constructor(IERC20Metadata currency_, IAccessManager access_) {
+    _currency = currency_;
+    _access = access_;
+  }
+
+  function currency() external view override returns (IERC20Metadata) {
+    return _currency;
+  }
+
+  function access() external view override returns (IAccessManager) {
+    return _access;
+  }
+
+  function treasury() external pure override returns (address) {
+    return address(0);
+  }
+
+  function newPolicy(
+    Policy.PolicyData memory policy,
+    address, /* caller */
+    address, /* policyHolder */
+    uint96 internalId
+  ) external override returns (uint256) {
+    policy.id = (uint256(uint160(address(policy.riskModule))) << 96) + internalId;
+    policyHashes[policy.id] = policy.hash();
+    emit NewPolicy(IRiskModule(msg.sender), policy);
+    return policy.id;
+  }
+
+  function _resolvePolicy(Policy.PolicyData memory policy, uint256 payout) internal {
+    require(policy.id != 0, "Policy not found");
+    require(policy.hash() == policyHashes[policy.id], "Hash doesn't match");
+    require(
+      msg.sender == address(policy.riskModule),
+      "Only riskModule is authorized to resolve the policy"
+    );
+    delete policies[policy.id];
+    delete policyHashes[policy.id];
+    emit PolicyResolved(IRiskModule(msg.sender), policy.id, payout);
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout) external override {
+    _resolvePolicy(policy, payout);
+  }
+
+  function expirePolicy(Policy.PolicyData calldata policy) external override {
+    _resolvePolicy(policy, 0);
+  }
+
+  function resolvePolicyFullPayout(Policy.PolicyData calldata policy, bool customerWon)
+    external
+    override
+  {
+    return _resolvePolicy(policy, customerWon ? policy.payout : 0);
+  }
+
+  function isActive(uint256 policyId) external view override returns (bool) {
+    return policyHashes[policyId] != bytes32(0);
+  }
+
+  function deposit(IEToken, uint256) external pure override {
+    revert("Not Implemented deposit");
+  }
+
+  function withdraw(IEToken, uint256) external pure override returns (uint256) {
+    revert("Not Implemented withdraw");
+  }
+
+  /**
+   * @dev Simple passthrough method for testing Policy.initialize
+   */
+  function initializeAndEmitPolicy(
+    IRiskModule riskModule,
+    IRiskModule.Params memory rmParams,
+    uint256 premium,
+    uint256 payout,
+    uint256 lossProb,
+    uint40 expiration
+  ) external {
+    Policy.PolicyData memory policy = Policy.initialize(
+      riskModule,
+      rmParams,
+      premium,
+      payout,
+      lossProb,
+      expiration
+    );
+
+    emit NewPolicy(riskModule, policy);
+  }
+}
+
+/**
+ * @title PolicyPoolMockForward
+ * @dev PolicyPool that forwards fallback calls to another contract. Used to simulate calls to EToken
+ *      and other contracts that have functions that can be called only from PolicyPool
+ */
+contract PolicyPoolMockForward is ForwardProxy {
+  uint256 public constant MAX_INT =
+    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
+
+  IERC20Metadata internal _currency;
+  IAccessManager internal _access;
+
+  constructor(
+    address forwardTo,
+    IERC20Metadata currency_,
+    IAccessManager access_
+  ) ForwardProxy(forwardTo) {
+    _currency = currency_;
+    _access = access_;
+  }
+
+  function currency() external view returns (IERC20Metadata) {
+    return _currency;
+  }
+
+  function access() external view returns (IAccessManager) {
+    return _access;
+  }
+}

package/contracts/mocks/RiskModuleMock.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import {IPolicyPool} from "../interfaces/IPolicyPool.sol";
+import {IPremiumsAccount} from "../interfaces/IPremiumsAccount.sol";
+import {RiskModule} from "../RiskModule.sol";
+import {Policy} from "../Policy.sol";
+
+/**
+ * @title Trustful Risk Module
+ * @dev Risk Module without any validation, just the newPolicy and resolvePolicy need to be called by
+        authorized users
+ * @custom:security-contact security@ensuro.co
+ * @author Ensuro
+ */
+
+contract RiskModuleMock is RiskModule {
+  bytes32 public constant PRICER_ROLE = keccak256("PRICER_ROLE");
+  bytes32 public constant RESOLVER_ROLE = keccak256("RESOLVER_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
+
+  /**
+   * @dev Initializes the RiskModule
+   * @param name_ Name of the Risk Module
+   * @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 collRatio_,
+    uint256 ensuroPpFee_,
+    uint256 srRoc_,
+    uint256 maxPayoutPerPolicy_,
+    uint256 exposureLimit_,
+    address wallet_
+  ) public initializer {
+    __RiskModule_init(
+      name_,
+      collRatio_,
+      ensuroPpFee_,
+      srRoc_,
+      maxPayoutPerPolicy_,
+      exposureLimit_,
+      wallet_
+    );
+  }
+
+  function newPolicy(
+    uint256 payout,
+    uint256 premium,
+    uint256 lossProb,
+    uint40 expiration,
+    address payer,
+    address onBehalfOf,
+    uint96 internalId
+  ) external onlyComponentRole(PRICER_ROLE) returns (uint256) {
+    return _newPolicy(payout, premium, lossProb, expiration, payer, onBehalfOf, internalId).id;
+  }
+
+  function resolvePolicy(Policy.PolicyData calldata policy, uint256 payout)
+    external
+    onlyComponentRole(RESOLVER_ROLE)
+  {
+    _policyPool.resolvePolicy(policy, payout);
+  }
+}