@etherisc/gif-next 0.0.2-b9e43cf-870 → 0.0.2-bb1081a-994

package/contracts/components/IPoolComponent.sol

@@ -1,43 +1,41 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {NftId} from "../types/NftId.sol";
 import {Fee} from "../types/Fee.sol";
+import {IComponent} from "./IComponent.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
+import {NftId} from "../types/NftId.sol";
 import {UFixed} from "../types/UFixed.sol";
 
-interface IPoolComponent {
+/// @dev pool components hold and manage the collateral to cover active policies
+/// pools come in different flavors
+interface IPoolComponent is IComponent {
 
     event LogUnderwrittenByPool(NftId policyNftId, uint256 collateralizationAmount, address pool);
 
+    error ErrorPoolNotPoolService(address service);
+
+    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+
     function setFees(
         Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee
     ) external;
 
-    /**
-     * @dev creates a new bundle for this pool.
-     */
-    function createBundle(
-        Fee memory fee,
-        uint256 initialAmount,
-        uint256 lifetime,
-        bytes memory filter
-    ) external returns(NftId bundleNftId);
-
+    /// @dev sets an additional bundle fee, this fee is added on top of the poolFee and deducted from the premium amounts.
+    /// via these fees individual bundler owner may earn income per policy in the context of peer to peer pools
     function setBundleFee(
-        NftId policyNftId, 
+        NftId bundleNftId, 
         Fee memory fee
     ) external;
 
-    /** 
-     * @dev this is a callback function that is called by the product service when underwriting a policy.
-     * the pool has the option to check the details and object to underwriting by reverting.
-     * the function is only called for "active" pools that ask to be involved/notified
-     * by product related state changes.
-     */
-    function underwrite(
-        NftId policyNftId, 
+    /// @dev this is a callback function that is called by the product service when underwriting a policy.
+    /// the pool has the option to check the details and object to underwriting by reverting.
+    /// the function is only called for "active" pools that ask to be involved/notified
+    /// by product related state changes.
+    function verifyApplication(
+        NftId applicationNftId, 
         bytes memory policyData,
         bytes memory bundleFilter,
         uint256 collateralizationAmount
@@ -47,10 +45,27 @@ interface IPoolComponent {
 
     function unlockBundle(NftId bundleNftId) external;
 
-    /**
-     * @dev returns true iff the policy application data in policyData matches
-     * with the bundle filter criteria encoded in bundleFilter. 
-     */
+    /// @dev defines the multiplier to calculate the required collateral to cover a given sum insured amount
+    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
+
+    /// @dev declares if pool intercept transfers of bundle nft ids
+    /// - yes: pool may block transfer of bundle ownership or simply updates some bookkeeping related to bundle ownership. callback function is nftTransferFrom
+    /// - no: pool is not involved in transfer of bundle ownership
+    function isInterceptingBundleTransfers() external view returns (bool);
+
+    /// @dev declares if pool relies on external management of collateral (yes/no): 
+    /// - yes: underwriting of new policies does not require an actual token balance, instead it is assumed that the pool owner will manage funds externally and inject enough tokens to allow process confirmed payouts
+    /// - no: the pool smart contract ensures that the necessary capacity of the pool prior to underwriting.
+    function isExternallyManaged() external view returns (bool);
+
+    /// @dev declares if pool component is actively involved in underwriting (yes/no): 
+    /// - yes: verifying pools components actively confirm underwriting applications, ie the pool component logic explicitly needs to confirm the locking of collateral to cover the sum insured of the policy
+    /// - no: underwriting a policy does not require any interaction with the pool component if the covering bundle can provide the necessary captial
+    function isVerifyingApplications() external view returns (bool);
+
+    /// @dev returns true iff the policy application data in policyData matches
+    /// with the bundle filter criteria encoded in bundleFilter
+    /// this is a callback function that is only called if a pool declares itself as a verifying pool
     function policyMatchesBundle(
         bytes memory policyData,
         bytes memory bundleFilter
@@ -59,8 +74,4 @@ interface IPoolComponent {
         view
         returns (bool isMatching);
 
-    function isConfirmingApplication() external view returns (bool isConfirmingApplication);
-
-    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
-
 }

package/contracts/components/IProductComponent.sol

@@ -2,11 +2,15 @@
 pragma solidity ^0.8.20;
 
 import {Fee} from "../types/Fee.sol";
+import {IComponent} from "./IComponent.sol";
+import {ISetup} from "../instance/module/ISetup.sol";
 import {NftId} from "../types/NftId.sol";
 import {ReferralId} from "../types/Referral.sol";
 import {RiskId} from "../types/RiskId.sol";
 
-interface IProductComponent {
+interface IProductComponent is IComponent {
+
+    function getSetupInfo() external view returns (ISetup.ProductSetupInfo memory setupInfo);
 
     function setFees(
         Fee memory productFee,
@@ -18,8 +22,8 @@ interface IProductComponent {
         RiskId riskId,
         uint256 lifetime,
         bytes memory applicationData,
-        ReferralId referralId,
-        NftId bundleNftId
+        NftId bundleNftId,
+        ReferralId referralId
     ) external view returns (uint256 premiumAmount);
 
     function calculateNetPremium(

package/contracts/components/Pool.sol

@@ -1,122 +1,107 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {ObjectType, POOL} from "../types/ObjectType.sol";
-import {IProductService} from "../instance/service/IProductService.sol";
+import {POOL} from "../types/ObjectType.sol";
 import {IPoolService} from "../instance/service/IPoolService.sol";
 import {IBundleService} from "../instance/service/IBundleService.sol";
-import {NftId, zeroNftId, NftIdLib} from "../types/NftId.sol";
+import {NftId, NftIdLib} from "../types/NftId.sol";
 import {Fee} from "../types/Fee.sol";
 import {UFixed} from "../types/UFixed.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
-import {BaseComponent} from "./BaseComponent.sol";
+import {Component} from "./Component.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {ISetup} from "../instance/module/ISetup.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 
-// import {IPool} from "../instance/module/pool/IPoolModule.sol";
-import {ITreasury} from "../instance/module/ITreasury.sol";
 import {ISetup} from "../instance/module/ISetup.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {Registerable} from "../shared/Registerable.sol";
 
-abstract contract Pool is BaseComponent, IPoolComponent {
-    using NftIdLib for NftId;
+abstract contract Pool is
+    Component, 
+    IPoolComponent 
+{
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Pool.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0xecf35607b7e822969ee3625cd815bfc27031f3a93d0be2676e5bde943e2e2300;
 
-    bool internal _isConfirmingApplication;
-    UFixed internal _collateralizationLevel;
+    struct PoolStorage {
+        UFixed _collateralizationLevel;
 
-    Fee internal _initialPoolFee;
-    Fee internal _initialStakingFee;
-    Fee internal _initialPerformanceFee;
+        bool _isExternallyManaged;
+        bool _isInterceptingBundleTransfers;
+        bool _isVerifyingApplications;
 
-    TokenHandler internal _tokenHandler;
+        Fee _initialPoolFee;
+        Fee _initialStakingFee;
+        Fee _initialPerformanceFee;
 
-    // may be used to interact with instance by derived contracts
-    IPoolService internal _poolService;
+        TokenHandler _tokenHandler;
 
-    // only relevant to protect callback functions for "active" pools
-    IProductService private _productService;
-
-    IBundleService private _bundleService;
+        // may be used to interact with instance by derived contracts
+        IPoolService _poolService;
+        IBundleService _bundleService;
+    }
 
     modifier onlyPoolService() {
-        require(
-            msg.sender == address(_poolService), 
-            "ERROR:POL-001:NOT_POOL_SERVICE");
+        if(msg.sender != address(_getStorage()._poolService)) {
+            revert ErrorPoolNotPoolService(msg.sender);
+        }
         _;
     }
 
-    modifier onlyProductService() {
-        require(
-            msg.sender == address(_productService), 
-            "ERROR:POL-002:NOT_PRODUCT_SERVICE");
-        _;
-    }
 
-    constructor(
+    function _initializePool(
         address registry,
         NftId instanceNftId,
+        string memory name,
         // TODO refactor into tokenNftId
         address token,
-        bool isInterceptor,
-        bool isConfirmingApplication,
         UFixed collateralizationLevel,
+        bool isInterceptingNftTransfers,
+        bool isExternallyManaging,
+        bool isVerifying,
         Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee,
-        address initialOwner
+        address initialOwner,
+        bytes memory data
     )
-        BaseComponent(registry, instanceNftId, token, POOL(), isInterceptor, initialOwner)
+        internal
+        //onlyInitializing//TODO uncomment when "fully" upgradeable
+        virtual
     {
-        _isConfirmingApplication = isConfirmingApplication;
+        _initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, data);
+
+        PoolStorage storage $ = _getStorage();
+
+        $._isExternallyManaged = isExternallyManaging;
+        $._isVerifyingApplications = isVerifying;
+
         // TODO add validation
-        _collateralizationLevel = collateralizationLevel;
-        _initialPoolFee = poolFee;
-        _initialStakingFee = stakingFee;
-        _initialPerformanceFee = performanceFee;
+        $._collateralizationLevel = collateralizationLevel;
+        $._initialPoolFee = poolFee;
+        $._initialStakingFee = stakingFee;
+        $._initialPerformanceFee = performanceFee;
 
-        _tokenHandler = new TokenHandler(token);
+        $._tokenHandler = new TokenHandler(token);
 
-        _poolService = _instance.getPoolService();
-        _productService = _instance.getProductService();
-        _bundleService = _instance.getBundleService();
+        $._poolService = getInstance().getPoolService();
+        $._bundleService = getInstance().getBundleService();
 
         _registerInterface(type(IPoolComponent).interfaceId);
     }
 
-    function createBundle(
-        Fee memory fee,
-        uint256 initialAmount,
-        uint256 lifetime,
-        bytes memory filter
-    )
-        external
-        virtual override
-        returns(NftId bundleNftId)
-    {
-        address owner = msg.sender;
-        bundleNftId = _bundleService.createBundle(
-            owner,
-            fee,
-            initialAmount,
-            lifetime,
-            filter
-        );
-
-        // TODO add logging
-    }
 
     /**
-     * @dev see {IPool.underwrite}. 
+     * @dev see {IPool.verifyApplication}. 
      * Default implementation that only writes a {LogUnderwrittenByPool} entry.
      */
-    function underwrite(
-        NftId policyNftId, 
-        bytes memory policyData,
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
         bytes memory bundleFilter,
         uint256 collateralizationAmount
     )
@@ -124,19 +109,43 @@ abstract contract Pool is BaseComponent, IPoolComponent {
         onlyProductService
         virtual override 
     {
-        _underwrite(policyNftId, policyData, bundleFilter, collateralizationAmount);
+        require(
+            policyMatchesBundle(applicationData, bundleFilter),
+            "ERROR:POL-020:POLICY_BUNDLE_MISMATCH"
+        );
+
+        emit LogUnderwrittenByPool(applicationNftId, collateralizationAmount, address(this));
     }
 
-    /**
-     * @dev see {IPoolComponent.policyMatchesBundle}. 
-     * Default implementation always returns true
-     */
+
+    function isInterceptingBundleTransfers() external view override returns (bool) {
+        return isNftInterceptor();
+    }
+
+
+    function isExternallyManaged() external view override returns (bool) {
+        return _getStorage()._isExternallyManaged;
+    }
+
+
+    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
+        return _getStorage()._collateralizationLevel;
+    }
+
+
+    function isVerifyingApplications() external view override returns (bool isConfirmingApplication) {
+        return _getStorage()._isVerifyingApplications;
+    }
+
+
+    /// @dev see {IPoolComponent.policyMatchesBundle}. 
+    /// Default implementation always returns true
     function policyMatchesBundle(
         bytes memory, // policyData
         bytes memory // bundleFilter
     )
         public
-        view
+        pure
         virtual override
         returns (bool isMatching)
     {
@@ -144,14 +153,6 @@ abstract contract Pool is BaseComponent, IPoolComponent {
     }
 
 
-    function isConfirmingApplication() external view override returns (bool isConfirmingApplication) {
-        return _isConfirmingApplication;
-    }
-
-    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
-        return _collateralizationLevel;
-    }
-
     function setFees(
         Fee memory poolFee,
         Fee memory stakingFee,
@@ -161,7 +162,7 @@ abstract contract Pool is BaseComponent, IPoolComponent {
         onlyOwner
         override
     {
-        _poolService.setFees(poolFee, stakingFee, performanceFee);
+        _getStorage()._poolService.setFees(poolFee, stakingFee, performanceFee);
     }
 
     function setBundleFee(
@@ -172,7 +173,7 @@ abstract contract Pool is BaseComponent, IPoolComponent {
         override
         // TODO add onlyBundleOwner
     {
-        _bundleService.setBundleFee(bundleNftId, fee);
+        _getStorage()._bundleService.setBundleFee(bundleNftId, fee);
     }
 
     function lockBundle(
@@ -182,7 +183,7 @@ abstract contract Pool is BaseComponent, IPoolComponent {
         override
         // TODO add onlyBundleOwner
     {
-        _bundleService.lockBundle(bundleNftId);
+        _getStorage()._bundleService.lockBundle(bundleNftId);
     }
 
     function unlockBundle(
@@ -192,81 +193,65 @@ abstract contract Pool is BaseComponent, IPoolComponent {
         override
         // TODO add onlyBundleOwner
     {
-        _bundleService.unlockBundle(bundleNftId);
+        _getStorage()._bundleService.unlockBundle(bundleNftId);
     }
 
     function getSetupInfo() public view returns (ISetup.PoolSetupInfo memory setupInfo) {
-        InstanceReader reader = _instance.getInstanceReader();
-        return reader.getPoolSetupInfo(getNftId());
-    }
+        InstanceReader reader = getInstance().getInstanceReader();
+        setupInfo = reader.getPoolSetupInfo(getNftId());
 
-    // from IRegisterable
+        // fallback to initial setup info (wallet is always != address(0))
+        if(setupInfo.wallet == address(0)) {
+            setupInfo = _getInitialSetupInfo();
+        }
+    }
 
-    // TODO used only once, occupies space
-    // TODO do not use super
-    function getInitialInfo() 
-        public
-        view
-        override (IRegisterable, Registerable)
-        returns (IRegistry.ObjectInfo memory, bytes memory)
-    {
-        (
-            IRegistry.ObjectInfo memory info, 
-        ) = super.getInitialInfo();
-
-        return (
-            info,
-            abi.encode(
-                getName(),
-                ISetup.PoolSetupInfo(
-                    _productNftId,
-                    _tokenHandler,
-                    _collateralizationLevel,
-                    _initialPoolFee,
-                    _initialStakingFee,
-                    _initialPerformanceFee,
-                    false,
-                    _isConfirmingApplication,
-                    _wallet
-                )
-            )
+    function _getInitialSetupInfo() internal view returns (ISetup.PoolSetupInfo memory) {
+        PoolStorage storage $ = _getStorage();
+        return ISetup.PoolSetupInfo(
+            getProductNftId(),
+            $._tokenHandler,
+            $._collateralizationLevel,
+            $._initialPoolFee,
+            $._initialStakingFee,
+            $._initialPerformanceFee,
+            isNftInterceptor(),
+            $._isVerifyingApplications,
+            getWallet()
         );
     }
 
     // Internals
 
-    function _underwrite(
-        NftId policyNftId, 
-        bytes memory policyData,
-        bytes memory bundleFilter,
-        uint256 collateralizationAmount
-    )
-        internal 
-    {
-        require(
-            policyMatchesBundle(policyData, bundleFilter),
-            "ERROR:POL-020:POLICY_BUNDLE_MISMATCH"
-        );
-
-        emit LogUnderwrittenByPool(policyNftId, collateralizationAmount, address(this));
-    }
-
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
         uint256 amount,
         uint256 lifetime, 
-        bytes calldata filter
+        bytes memory filter
     )
         internal
         returns(NftId bundleNftId)
     {
-        bundleNftId = _bundleService.createBundle(
+        bundleNftId = _getStorage()._bundleService.createBundle(
             bundleOwner,
             fee,
             amount,
             lifetime,
-            filter
-        );
+            filter);
+
+        // TODO add logging
+    }
+
+    function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
+        return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
     }
+
+
+    function _getStorage() private pure returns (PoolStorage storage $) {
+        assembly {
+            $.slot := POOL_STORAGE_LOCATION_V1
+        }
+    }
+
 }