@etherisc/gif-next 0.0.2-eb98db7-932 → 0.0.2-ebf1a6b-485

package/contracts/components/IPoolComponent.sol

@@ -5,46 +5,95 @@ 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 {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);
+    error ErrorPoolBundleOwnerRoleAlreadySet();
 
-    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+    event LogPoolVerifiedByPool(address pool, NftId applicationNftId, uint256 collateralizationAmount);
+    event LogPoolBundleMaxCapitalAmountUpdated(uint256 previousMaxCapitalAmount, uint256 currentMaxCapitalAmount);
+    event LogPoolBundleOwnerRoleSet(RoleId bundleOwnerRole);
 
-    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 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 sets an additional bundle fee, this fee is added on top of the poolFee and deducted from the premium amounts.
+    /// @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);
@@ -54,12 +103,6 @@ interface IPoolComponent is IComponent {
     /// 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.
@@ -72,16 +115,37 @@ interface IPoolComponent is IComponent {
     /// 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 the maximum overall capital amound held by this pool
+    function getMaxCapitalAmount() external view returns (uint256 maxCapitalAmount);
+
+    /// @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 returns the required role for bundle owners
+    /// default emplementation returns PUBLIC_ROLE
+    /// the PUBLIC_ROLE role implies that no specific roole is required for bundle owners
+    function getBundleOwnerRole() external view returns (RoleId bundleOwnerRole);
+
+    /// @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 setup infos for this pool
+    /// when registered with an instance the setup info is obtained from the data stored in the instance
+    /// when not registered the function returns the initial setup info
+    function getSetupInfo() external view returns (ISetup.PoolSetupInfo memory setupInfo);
+
 }

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 {TokenHandler} from "../shared/TokenHandler.sol";
-import {ISetup} from "../instance/module/ISetup.sol";
-
+import {IPoolService} from "../instance/service/IPoolService.sol";
 import {ISetup} from "../instance/module/ISetup.sol";
-import {InstanceReader} from "../instance/InstanceReader.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 {UFixed} from "../types/UFixed.sol";
 
 
 abstract contract Pool is
@@ -26,11 +26,14 @@ abstract contract Pool is
     struct PoolStorage {
         UFixed _collateralizationLevel;
         UFixed _retentionLevel;
-
+        uint256 _maxCapitalAmount;
+        
         bool _isExternallyManaged;
-        bool _isInterceptingBundleTransfers;
         bool _isVerifyingApplications;
 
+        RoleId _bundleOwnerRole;
+        bool _isInterceptingBundleTransfers;
+
         Fee _initialPoolFee;
         Fee _initialStakingFee;
         Fee _initialPerformanceFee;
@@ -42,6 +45,15 @@ abstract contract Pool is
         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,7 +66,6 @@ abstract contract Pool is
         address registry,
         NftId instanceNftId,
         string memory name,
-        // TODO refactor into tokenNftId
         address token,
         bool isInterceptingNftTransfers,
         bool isExternallyManaging,
@@ -62,19 +73,21 @@ abstract contract Pool is
         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);
+        $._maxCapitalAmount = type(uint256).max;
         $._isExternallyManaged = isExternallyManaging;
         $._isVerifyingApplications = isVerifying;
+        $._bundleOwnerRole = PUBLIC_ROLE();
         $._collateralizationLevel = collateralizationLevel;
         $._retentionLevel = retentionLevel;
         $._initialPoolFee = FeeLib.zeroFee();
@@ -86,66 +99,121 @@ abstract contract Pool is
         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()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.lockBundle(bundleNftId);
     }
 
 
-    function getCollateralizationLevel() external view override returns (UFixed collateralizationLevel) {
-        return _getPoolStorage()._collateralizationLevel;
+    function unlockBundle(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        _getPoolStorage()._bundleService.unlockBundle(bundleNftId);
     }
 
 
-    function isVerifyingApplications() external view override returns (bool isConfirmingApplication) {
-        return _getPoolStorage()._isVerifyingApplications;
+    function close(NftId bundleNftId)
+        public
+        virtual
+        restricted()
+        onlyBundleOwner(bundleNftId)
+    {
+        // TODO add implementation
     }
 
 
-    /// @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.setBundleFee(bundleNftId, fee);
+    }
+
+
+    function setMaxCapitalAmount(uint256 maxCapitalAmount)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        // TODO refactor to use pool service
+        // _getPoolStorage()._poolService.setMaxCapitalAmount(...);
+
+        uint256 previousMaxCapitalAmount = _getPoolStorage()._maxCapitalAmount;
+        _getPoolStorage()._maxCapitalAmount = maxCapitalAmount;
+
+        emit LogPoolBundleMaxCapitalAmountUpdated(previousMaxCapitalAmount, maxCapitalAmount);
+    }
+
+
+    function setBundleOwnerRole(RoleId bundleOwnerRole)
+        public
+        virtual
+        restricted()
+        onlyOwner()
+    {
+        // TODO refactor to use pool service
+        // _getPoolStorage()._poolService.setBundleOwnerRole(...);
+
+        if(_getPoolStorage()._bundleOwnerRole != PUBLIC_ROLE()) {
+            revert ErrorPoolBundleOwnerRoleAlreadySet();
+        }
+
+        _getPoolStorage()._bundleOwnerRole = bundleOwnerRole;
+
+        emit LogPoolBundleOwnerRoleSet(bundleOwnerRole);
     }
 
 
@@ -154,45 +222,97 @@ 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);
+        // validate application data against bundle filter
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            applicationData, 
+            bundleNftId, 
+            bundleFilter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
+        }
+
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
     }
 
-    function lockBundle(
-        NftId bundleNftId
-    )
-        external
-        override
-        // TODO add onlyBundleOwner
-    {
-        _getPoolStorage()._bundleService.lockBundle(bundleNftId);
+
+    function getCollateralizationLevel() public view virtual returns (UFixed collateralizationLevel) {
+        return _getPoolStorage()._collateralizationLevel;
+    }
+
+
+    function getRetentionLevel() public view virtual returns (UFixed retentionLevel) {
+        return _getPoolStorage()._retentionLevel;
+    }
+
+
+    function isExternallyManaged() public view virtual returns (bool) {
+        return _getPoolStorage()._isExternallyManaged;
+    }
+
+
+    function isVerifyingApplications() public view virtual returns (bool isConfirmingApplication) {
+        return _getPoolStorage()._isVerifyingApplications;
+    }
+
+
+    function getMaxCapitalAmount() public view virtual returns (uint256 maxCapitalAmount) {
+        return _getPoolStorage()._maxCapitalAmount;
+    }
+
+
+    function isInterceptingBundleTransfers() public view virtual returns (bool) {
+        return isNftInterceptor();
+    }
+
+
+    function getBundleOwnerRole() public view returns (RoleId bundleOwnerRole) {
+        return _getPoolStorage()._bundleOwnerRole;
     }
 
-    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());
@@ -203,30 +323,13 @@ abstract contract Pool is
         }
     }
 
-    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()
-        );
-    }
-
     // Internals
 
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
         uint256 amount,
-        uint256 lifetime, 
+        Seconds lifetime, 
         bytes memory filter
     )
         internal
@@ -242,10 +345,31 @@ 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));
     }
 
+
+    function _getInitialSetupInfo() internal view returns (ISetup.PoolSetupInfo memory) {
+        PoolStorage storage $ = _getPoolStorage();
+        return ISetup.PoolSetupInfo(
+            getProductNftId(),
+            $._tokenHandler,
+            $._maxCapitalAmount,
+            isNftInterceptor(),
+            $._isExternallyManaged,
+            $._isVerifyingApplications,
+            $._collateralizationLevel,
+            $._retentionLevel,
+            $._initialPoolFee,
+            $._initialStakingFee,
+            $._initialPerformanceFee,
+            getWallet()
+        );
+    }
+
+
     function _getPoolStorage() private pure returns (PoolStorage storage $) {
         assembly {
             $.slot := POOL_STORAGE_LOCATION_V1