@etherisc/gif-next 0.0.2-bfb44e0-483 → 0.0.2-c0b400a-177

package/contracts/components/IPoolComponent.sol

@@ -3,85 +3,111 @@ pragma solidity ^0.8.20;
 
 import {Fee} from "../types/Fee.sol";
 import {IComponent} from "./IComponent.sol";
-import {ISetup} from "../instance/module/ISetup.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
 import {NftId} from "../types/NftId.sol";
+import {RoleId} from "../types/RoleId.sol";
+import {Seconds} from "../types/Seconds.sol";
 import {UFixed} from "../types/UFixed.sol";
 
 /// @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 ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
+    error ErrorPoolNotPoolService(address caller);
 
-    error ErrorPoolNotPoolService(address service);
+    error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
-    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, uint256 collateralizationAmount);
 
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    ) external;
+    /// @dev increases the staked tokens by the specified amount
+    /// only the bundle owner may stake tokens
+    /// bundle MUST be in active or locked state
+    function stake(NftId bundleNftId, uint256 amount) external;
+
+    /// @dev decreases the staked tokens by the specified amount
+    /// only the bundle owner may unstake tokens from the bundle
+    /// bundle MUST be in active, locked or closed state
+    function unstake(NftId bundleNftId, uint256 amount) external;
 
-    /// @dev sets an additional bundle fee, this fee is added on top of the poolFee and deducted from the premium amounts.
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// only the bundle owner may extend the bundle's lifetime
+    /// bundle MUST be in active or locked state
+    function extend(NftId bundleNftId, Seconds lifetimeExtension) external;
+
+    /// @dev locks the specified bundle
+    /// a bundle to be locked MUST be in active state
+    /// locked bundles may not be used to underwrite any new policy
+    function lockBundle(NftId bundleNftId) external;
+
+    /// @dev unlocks the specified bundle
+    /// a bundle to be unlocked MUST be in locked state
+    function unlockBundle(NftId bundleNftId) external;
+
+    /// @dev close the specified bundle
+    /// a bundle to be closed MUST be in active or locked state
+    /// to close a bundle all all linked policies MUST be in closed state as well
+    /// closing a bundle finalizes the bundle bookkeeping including overall profit calculation
+    /// once a bundle is closed this action cannot be reversed
+    function close(NftId bundleNftId) external;
+
+    /// @dev sets the fee for the specified bundle
+    /// the 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 bundleNftId, 
         Fee memory fee
     ) external;
 
+    /// @dev sets the maximum overall capital amound held by this pool
+    /// function may only be called by pool owner
+    function setMaxCapitalAmount(uint256 maxCapitalAmount) external;
+
+    /// @dev sets the required role to create/own bundles
+    /// may only be called once after setting up a pool
+    /// may only be called by pool owner 
+    function setBundleOwnerRole(RoleId bundleOwnerRole) external;
+
+    /// @dev update pool fees to the specified values
+    /// pool fees: are deducted from the premium amount and goes to the pool owner
+    /// staking fees: are deducted from the staked tokens by a bundle owner and goes to the pool owner
+    /// performance fees: when a bundle is closed a bundle specific profit is calculated
+    /// the performance fee is deducted from this profit and goes to the pool owner
+    function setFees(
+        Fee memory poolFee,
+        Fee memory stakingFee,
+        Fee memory performanceFee
+    ) 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 verifyApplication(
         NftId applicationNftId, 
-        bytes memory policyData,
+        bytes memory applicationData,
+        NftId bundleNftId, 
         bytes memory bundleFilter,
         uint256 collateralizationAmount
     ) external;
 
-    function lockBundle(NftId bundleNftId) external;
-
-    function unlockBundle(NftId bundleNftId) external;
-
-    /// @dev defines the multiplier to calculate the required collateral to cover a given sum insured amount
-    /// default implementation returns 100%
-    function getCollateralizationLevel() external view returns (UFixed collateralizationLevel);
-
-    /// @dev defines the amount of collateral held in the pool.
-    /// if the value is < 100% the pool is required to hold a policy that covers the locally missing collateral
-    /// default implementation returns 100%
-    function getRetentionLevel() external view returns (UFixed retentionLevel);
-
-    /// @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
-    /// default implementation returns false (no)
-    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.
-    /// default implementation returns false (no)
-    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
-    /// default implementation returnsfalse (no)
-    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
+    /// @dev returns true iff the application matches with the bundle 
     /// this is a callback function that is only called if a pool declares itself as a verifying pool
     /// default implementation returns true
-    function policyMatchesBundle(
-        bytes memory policyData,
-        bytes memory bundleFilter
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
     )
         external
         view
         returns (bool isMatching);
 
+    /// @dev returns pool specific infos for this pool
+    /// when registered with an instance the info is obtained from the data stored in the instance
+    /// when not registered the function returns the info from the component contract
+    function getPoolInfo() external view returns (IComponents.PoolInfo memory info);
+
 }

package/contracts/components/IProductComponent.sol

@@ -7,6 +7,7 @@ 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";
+import {Seconds} from "../types/Seconds.sol";
 
 interface IProductComponent is IComponent {
 
@@ -20,7 +21,7 @@ interface IProductComponent is IComponent {
     function calculatePremium(
         uint256 sumInsuredAmount,
         RiskId riskId,
-        uint256 lifetime,
+        Seconds lifetime,
         bytes memory applicationData,
         NftId bundleNftId,
         ReferralId referralId
@@ -29,7 +30,7 @@ interface IProductComponent is IComponent {
     function calculateNetPremium(
         uint256 sumInsuredAmount,
         RiskId riskId,
-        uint256 lifetime,
+        Seconds lifetime,
         bytes memory applicationData
     ) external view returns (uint256 netPremiumAmount);    
 

package/contracts/components/Pool.sol

@@ -1,19 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {POOL} from "../types/ObjectType.sol";
-import {IPoolService} from "../instance/service/IPoolService.sol";
-import {IBundleService} from "../instance/service/IBundleService.sol";
-import {NftId, NftIdLib} from "../types/NftId.sol";
+import {Component} from "./Component.sol";
 import {Fee, FeeLib} from "../types/Fee.sol";
-import {UFixed} from "../types/UFixed.sol";
+import {IBundleService} from "../instance/service/IBundleService.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
-import {Component} from "./Component.sol";
+import {IPoolService} from "../instance/service/IPoolService.sol";
+import {IComponents} from "../instance/module/IComponents.sol";
+import {NftId, NftIdLib} from "../types/NftId.sol";
+import {POOL} from "../types/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../types/RoleId.sol";
+import {Seconds} from "../types/Seconds.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {ISetup} from "../instance/module/ISetup.sol";
-
-import {ISetup} from "../instance/module/ISetup.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
+import {UFixed, UFixedLib} from "../types/UFixed.sol";
 
 
 abstract contract Pool is
@@ -24,24 +24,19 @@ abstract contract Pool is
     bytes32 public constant POOL_STORAGE_LOCATION_V1 = 0x25e3e51823fbfffb988e0a2744bb93722d9f3e906c07cc0a9e77884c46c58300;
 
     struct PoolStorage {
-        UFixed _collateralizationLevel;
-        UFixed _retentionLevel;
-
-        bool _isExternallyManaged;
-        bool _isInterceptingBundleTransfers;
-        bool _isVerifyingApplications;
-
-        Fee _initialPoolFee;
-        Fee _initialStakingFee;
-        Fee _initialPerformanceFee;
-
-        TokenHandler _tokenHandler;
-
-        // may be used to interact with instance by derived contracts
         IPoolService _poolService;
         IBundleService _bundleService;
     }
 
+
+    modifier onlyBundleOwner(NftId bundleNftId) {
+        if(msg.sender != getRegistry().ownerOf(bundleNftId)) {
+            revert ErrorPoolNotBundleOwner(bundleNftId, msg.sender);
+        }
+        _;
+    }
+
+
     modifier onlyPoolService() {
         if(msg.sender != address(_getPoolStorage()._poolService)) {
             revert ErrorPoolNotPoolService(msg.sender);
@@ -54,98 +49,124 @@ abstract contract Pool is
         address registry,
         NftId instanceNftId,
         string memory name,
-        // TODO refactor into tokenNftId
         address token,
         bool isInterceptingNftTransfers,
-        bool isExternallyManaging,
-        bool isVerifying,
-        UFixed collateralizationLevel,
-        UFixed retentionLevel,
         address initialOwner,
-        bytes memory data
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
     )
         public
         virtual
         onlyInitializing()
     {
-        initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, data);
+        initializeComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, registryData);
 
         PoolStorage storage $ = _getPoolStorage();
-        // TODO add validation
-        $._tokenHandler = new TokenHandler(token);
-        $._isExternallyManaged = isExternallyManaging;
-        $._isVerifyingApplications = isVerifying;
-        $._collateralizationLevel = collateralizationLevel;
-        $._retentionLevel = retentionLevel;
-        $._initialPoolFee = FeeLib.zeroFee();
-        $._initialStakingFee = FeeLib.zeroFee();
-        $._initialPerformanceFee = FeeLib.zeroFee();
         $._poolService = getInstance().getPoolService();
         $._bundleService = getInstance().getBundleService();
 
         registerInterface(type(IPoolComponent).interfaceId);
     }
 
-    /**
-     * @dev see {IPool.verifyApplication}. 
-     * Default implementation that only writes a {LogUnderwrittenByPool} entry.
-     */
-    function verifyApplication(
-        NftId applicationNftId, 
-        bytes memory applicationData,
-        bytes memory bundleFilter,
-        uint256 collateralizationAmount
+
+    function stake(
+        NftId bundleNftId, 
+        uint256 amount
     )
-        external
+        public
+        virtual
         restricted()
-        virtual override 
+        onlyBundleOwner(bundleNftId)
     {
-        require(
-            policyMatchesBundle(applicationData, bundleFilter),
-            "ERROR:POL-020:POLICY_BUNDLE_MISMATCH"
-        );
-
-        emit LogUnderwrittenByPool(applicationNftId, collateralizationAmount, address(this));
+        // TODO add implementation
     }
 
 
-    function isInterceptingBundleTransfers() external view override returns (bool) {
-        return isNftInterceptor();
+    function unstake(
+        NftId bundleNftId, 
+        uint256 amount
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
     }
 
 
-    function isExternallyManaged() external view override returns (bool) {
-        return _getPoolStorage()._isExternallyManaged;
+    function extend(
+        NftId bundleNftId, 
+        Seconds lifetimeExtension
+    )
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
     }
 
 
-    function getRetentionLevel() external view override returns (UFixed retentionLevel) {
-        return _getPoolStorage()._retentionLevel;
+    function lockBundle(NftId bundleNftId)
+        public
+        virtual
+        //restricted() // TODO consider adding this back
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.lock(bundleNftId);
     }
 
 
-    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
-        return _getPoolStorage()._collateralizationLevel;
+    function unlockBundle(NftId bundleNftId)
+        public
+        virtual
+        //restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.unlock(bundleNftId);
     }
 
 
-    function isVerifyingApplications() external view override returns (bool isConfirmingApplication) {
-        return _getPoolStorage()._isVerifyingApplications;
+    function close(NftId bundleNftId)
+        public
+        virtual
+        //restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.close(bundleNftId);
     }
 
 
-    /// @dev see {IPoolComponent.policyMatchesBundle}. 
-    /// Default implementation always returns true
-    function policyMatchesBundle(
-        bytes memory, // policyData
-        bytes memory // bundleFilter
+    function setBundleFee(
+        NftId bundleNftId, 
+        Fee memory fee
     )
         public
-        pure
-        virtual override
-        returns (bool isMatching)
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
     {
-        return true;
+        _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
+    }
+
+
+    function setMaxCapitalAmount(uint256 maxCapitalAmount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+    }
+
+
+    function setBundleOwnerRole(RoleId bundleOwnerRole)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        _getPoolStorage()._poolService.setBundleOwnerRole(bundleOwnerRole);
     }
 
 
@@ -154,70 +175,63 @@ abstract contract Pool is
         Fee memory stakingFee,
         Fee memory performanceFee
     )
-        external
-        onlyOwner
+        public
+        virtual
         restricted()
-        override
+        onlyOwner()
     {
         _getPoolStorage()._poolService.setFees(poolFee, stakingFee, performanceFee);
     }
 
-    function setBundleFee(
+
+    /// @dev see {IPool.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
         NftId bundleNftId, 
-        Fee memory fee
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
     )
-        external
-        override
-        // TODO add onlyBundleOwner
+        public
+        virtual
+        restricted()
     {
-        _getPoolStorage()._bundleService.setBundleFee(bundleNftId, fee);
-    }
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            applicationData, 
+            bundleNftId, 
+            bundleFilter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
 
-    function lockBundle(
-        NftId bundleNftId
-    )
-        external
-        override
-        // TODO add onlyBundleOwner
-    {
-        _getPoolStorage()._bundleService.lockBundle(bundleNftId);
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
     }
 
-    function unlockBundle(
-        NftId bundleNftId
+
+    /// @dev see {IPoolComponent.applicationMatchesBundle}
+    /// Override this function to implement any custom application verification 
+    /// Default implementation always returns true
+    function applicationMatchesBundle(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        uint256 collateralizationAmount
     )
-        external
-        override
-        // TODO add onlyBundleOwner
+        public
+        view
+        virtual override
+        returns (bool isMatching)
     {
-        _getPoolStorage()._bundleService.unlockBundle(bundleNftId);
+        return true;
     }
 
-    function getSetupInfo() public view returns (ISetup.PoolSetupInfo memory setupInfo) {
-        InstanceReader reader = getInstance().getInstanceReader();
-        setupInfo = reader.getPoolSetupInfo(getNftId());
-
-        // fallback to initial setup info (wallet is always != address(0))
-        if(setupInfo.wallet == address(0)) {
-            setupInfo = _getInitialSetupInfo();
-        }
-    }
 
-    function _getInitialSetupInfo() internal view returns (ISetup.PoolSetupInfo memory) {
-        PoolStorage storage $ = _getPoolStorage();
-        return ISetup.PoolSetupInfo(
-            getProductNftId(),
-            $._tokenHandler,
-            isNftInterceptor(),
-            $._isExternallyManaged,
-            $._isVerifyingApplications,
-            $._collateralizationLevel,
-            $._retentionLevel,
-            $._initialPoolFee,
-            $._initialStakingFee,
-            $._initialPerformanceFee,
-            getWallet()
-        );
+    function getPoolInfo() external view returns (IComponents.PoolInfo memory poolInfo) {
+        poolInfo = abi.decode(getComponentInfo().data, (IComponents.PoolInfo));
     }
 
     // Internals
@@ -226,13 +240,13 @@ abstract contract Pool is
         address bundleOwner,
         Fee memory fee,
         uint256 amount,
-        uint256 lifetime, 
+        Seconds lifetime, 
         bytes memory filter
     )
         internal
         returns(NftId bundleNftId)
     {
-        bundleNftId = _getPoolStorage()._bundleService.createBundle(
+        bundleNftId = _getPoolStorage()._bundleService.create(
             bundleOwner,
             fee,
             amount,
@@ -242,10 +256,41 @@ abstract contract Pool is
         // TODO add logging
     }
 
+    // TODO remove function once this is no longer used to produce contract locations on the fly ...
     function getContractLocation(bytes memory name) external pure returns (bytes32 hash) {
         return keccak256(abi.encode(uint256(keccak256(name)) - 1)) & ~bytes32(uint256(0xff));
     }
 
+    /// @dev defines initial pool specification
+    /// overwrite this function according to your use case
+    function _getInitialInfo()
+        internal
+        view 
+        virtual override
+        returns (IComponents.ComponentInfo memory info)
+    {
+        return IComponents.ComponentInfo(
+            getName(),
+            getToken(),
+            TokenHandler(address(0)), // will be created by GIF service during registration
+            address(this), // contract is its own wallet
+            abi.encode(
+                IComponents.PoolInfo(
+                    NftIdLib.zero(), // will be set when GIF registers the related product
+                    PUBLIC_ROLE(), // bundleOwnerRole
+                    type(uint256).max, // maxCapitalAmount,
+                    isNftInterceptor(), // isInterceptingBundleTransfers
+                    false, // isExternallyManaged,
+                    false, // isVerifyingApplications,
+                    UFixedLib.toUFixed(1), // collateralizationLevel,
+                    UFixedLib.toUFixed(1), // retentionLevel,
+                    FeeLib.zeroFee(), // initialPoolFee,
+                    FeeLib.zeroFee(), // initialStakingFee,
+                    FeeLib.zeroFee() // initialPerformanceFee,
+                )));
+    }
+
+
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {
             $.slot := POOL_STORAGE_LOCATION_V1