@etherisc/gif-next 0.0.2-7f39e38-904 → 0.0.2-804cdbf-724

package/contracts/pool/IPoolComponent.sol

@@ -16,70 +16,10 @@ interface IPoolComponent is IInstanceLinkedComponent {
 
     error ErrorPoolNotBundleOwner(NftId bundleNftId, address caller);
     error ErrorPoolNotPoolService(address caller);
-
     error ErrorPoolApplicationBundleMismatch(NftId applicationNftId);
 
     event LogPoolVerifiedByPool(address pool, NftId applicationNftId, Amount collateralizationAmount);
 
-    /// @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, Amount 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, Amount 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 collateralize 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(Amount 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

package/contracts/pool/IPoolService.sol

@@ -48,6 +48,7 @@ interface IPoolService is IService {
     /// may only be called by the policy service for unlocked pool components
     function lockCollateral(
         IInstance instance, 
+        address token,
         NftId productNftId,
         NftId applicationNftId,
         NftId bundleNftId,
@@ -64,6 +65,7 @@ interface IPoolService is IService {
     /// may only be called by the policy service for unlocked pool components
     function releaseCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo
     ) external;
@@ -74,6 +76,7 @@ interface IPoolService is IService {
     /// may only be called by the claim service for unlocked pool components
     function reduceCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo,
         Amount payoutAmount

package/contracts/pool/Pool.sol

@@ -2,15 +2,16 @@
 pragma solidity ^0.8.20;
 
 import {Amount, AmountLib} from "../type/Amount.sol";
-import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
 import {IBundleService} from "./IBundleService.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IPoolComponent} from "./IPoolComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
+import {InstanceLinkedComponent} from "../shared/InstanceLinkedComponent.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {BUNDLE, COMPONENT, POOL} from "../type/ObjectType.sol";
 import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Seconds} from "../type/Seconds.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
@@ -38,29 +39,110 @@ abstract contract Pool is
     }
 
 
-    modifier onlyPoolService() {
-        if(msg.sender != address(_getPoolStorage()._poolService)) {
-            revert ErrorPoolNotPoolService(msg.sender);
+    /// @dev see {IPoolComponent.verifyApplication}
+    function verifyApplication(
+        NftId applicationNftId, 
+        bytes memory applicationData,
+        NftId bundleNftId, 
+        bytes memory bundleFilter,
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        restricted()
+    {
+        if(!applicationMatchesBundle(
+            applicationNftId,
+            applicationData, 
+            bundleNftId, 
+            bundleFilter,
+            collateralizationAmount)
+        )
+        {
+            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
         }
-        _;
+
+        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
+    }
+
+
+    /// @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,
+        Amount collateralizationAmount
+    )
+        public
+        virtual
+        view
+        returns (bool isMatching)
+    {
+        return true;
     }
 
 
-    function initializePool(
+    function register()
+        external
+        virtual
+        onlyOwner()
+    {
+        _getPoolStorage()._componentService.registerPool();
+    }
+
+
+    function getInitialPoolInfo()
+        public 
+        virtual 
+        view 
+        returns (IComponents.PoolInfo memory poolInfo)
+    {
+        return IComponents.PoolInfo(
+            NftIdLib.zero(), // will be set when GIF registers the related product
+            PUBLIC_ROLE(), // bundleOwnerRole
+            AmountLib.max(), // maxCapitalAmount,
+            isNftInterceptor(), // isInterceptingBundleTransfers
+            false, // isExternallyManaged,
+            false, // isVerifyingApplications,
+            UFixedLib.toUFixed(1), // collateralizationLevel,
+            UFixedLib.toUFixed(1), // retentionLevel,
+            FeeLib.zero(), // initialPoolFee,
+            FeeLib.zero(), // initialStakingFee,
+            FeeLib.zero() // initialPerformanceFee,
+        );
+    }
+
+    // Internals
+
+    function _initializePool(
         address registry,
         NftId instanceNftId,
         string memory name,
         address token,
+        IAuthorization authorization,
         bool isInterceptingNftTransfers,
         address initialOwner,
         bytes memory registryData, // writeonly data that will saved in the object info record of the registry
         bytes memory componentData // component specifidc data 
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeInstanceLinkedComponent(registry, instanceNftId, name, token, POOL(), isInterceptingNftTransfers, initialOwner, registryData, componentData);
+        _initializeInstanceLinkedComponent(
+            registry, 
+            instanceNftId, 
+            name, 
+            token, 
+            POOL(), 
+            authorization, 
+            isInterceptingNftTransfers, 
+            initialOwner, 
+            registryData, 
+            componentData);
 
         PoolStorage storage $ = _getPoolStorage();
         $._poolService = IPoolService(_getServiceAddress(POOL())); 
@@ -70,201 +152,130 @@ abstract contract Pool is
         registerInterface(type(IPoolComponent).interfaceId);
     }
 
-
-    function register()
-        external
-        virtual
-        onlyOwner()
-    {
-        _getPoolStorage()._componentService.registerPool();
-    }
-
-
-    function stake(
+    /// @dev increases the staked tokens by the specified amount
+    /// bundle MUST be in active or locked state
+    function _stake(
         NftId bundleNftId, 
         Amount amount
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
     {
         // TODO add implementation
     }
 
 
-    function unstake(
+    /// @dev decreases the staked tokens by the specified amount
+    /// bundle MUST be in active, locked or closed state
+    function _unstake(
         NftId bundleNftId, 
         Amount amount
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
     {
         // TODO add implementation
     }
 
 
-    function extend(
+    /// @dev extends the bundle lifetime of the bundle by the specified time
+    /// bundle MUST be in active or locked state
+    function _extend(
         NftId bundleNftId, 
         Seconds lifetimeExtension
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyBundleOwner(bundleNftId)
     {
         // TODO add implementation
     }
 
 
-    function lockBundle(NftId bundleNftId)
-        public
+    /// @dev Locks the specified bundle.
+    /// A bundle to be locked MUST be in active state.
+    /// Locked bundles may not be used to collateralize any new policy.
+    function _lockBundle(NftId bundleNftId)
+        internal
         virtual
-        //restricted() // TODO consider adding this back
-        onlyBundleOwner(bundleNftId)
     {
         _getPoolStorage()._bundleService.lock(bundleNftId);
     }
 
 
-    function unlockBundle(NftId bundleNftId)
-        public
+    /// @dev Unlocks the specified bundle.
+    /// A bundle to be unlocked MUST be in locked state.
+    function _unlockBundle(NftId bundleNftId)
+        internal
         virtual
-        //restricted()
-        onlyBundleOwner(bundleNftId)
     {
         _getPoolStorage()._bundleService.unlock(bundleNftId);
     }
 
 
-    function close(NftId bundleNftId)
-        public
+    /// @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)
+        internal
         virtual
-        //restricted()
-        onlyBundleOwner(bundleNftId)
     {
         _getPoolStorage()._poolService.closeBundle(bundleNftId);
     }
 
 
-    function setBundleFee(
+    /// @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
     )
-        public
+        internal
         virtual
-        //restricted()
-        onlyBundleOwner(bundleNftId)
     {
         _getPoolStorage()._bundleService.setFee(bundleNftId, fee);
     }
 
 
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
-        public
+    /// @dev Sets the maximum overall capital amound held by this pool.
+    /// Function may only be called by pool owner.
+    function _setMaxCapitalAmount(Amount maxCapitalAmount)
+        internal
         virtual
-        restricted()
-        onlyOwner()
     {
         _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
     }
 
-
-    function setBundleOwnerRole(RoleId bundleOwnerRole)
-        public
+    /// @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)
+        internal
         virtual
-        restricted()
-        onlyOwner()
     {
         _getPoolStorage()._poolService.setBundleOwnerRole(bundleOwnerRole);
     }
 
 
-    function setFees(
+    /// @dev Update pool fees to the specified values.
+    /// Pool fee: are deducted from the premium amount and goes to the pool owner.
+    /// Staking fee: are deducted from the staked tokens by a bundle owner and goes to the pool owner.
+    /// Performance fee: 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 _setPoolFees(
         Fee memory poolFee,
         Fee memory stakingFee,
         Fee memory performanceFee
     )
-        public
+        internal
         virtual
-        restricted()
-        onlyOwner()
     {
         _getPoolStorage()._componentService.setPoolFees(poolFee, stakingFee, performanceFee);
     }
 
-
-    /// @dev see {IPool.verifyApplication}
-    function verifyApplication(
-        NftId applicationNftId, 
-        bytes memory applicationData,
-        NftId bundleNftId, 
-        bytes memory bundleFilter,
-        Amount collateralizationAmount
-    )
-        public
-        virtual
-        restricted()
-    {
-        if(!applicationMatchesBundle(
-            applicationNftId,
-            applicationData, 
-            bundleNftId, 
-            bundleFilter,
-            collateralizationAmount)
-        )
-        {
-            revert ErrorPoolApplicationBundleMismatch(applicationNftId);
-        }
-
-        emit LogPoolVerifiedByPool(address(this), applicationNftId, collateralizationAmount);
-    }
-
-
-    /// @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,
-        Amount collateralizationAmount
-    )
-        public
-        view
-        virtual override
-        returns (bool isMatching)
-    {
-        return true;
-    }
-
-
-    function getInitialPoolInfo()
-        public 
-        virtual 
-        view 
-        returns (IComponents.PoolInfo memory poolInfo)
-    {
-        return IComponents.PoolInfo(
-            NftIdLib.zero(), // will be set when GIF registers the related product
-            PUBLIC_ROLE(), // bundleOwnerRole
-            AmountLib.max(), // maxCapitalAmount,
-            isNftInterceptor(), // isInterceptingBundleTransfers
-            false, // isExternallyManaged,
-            false, // isVerifyingApplications,
-            UFixedLib.toUFixed(1), // collateralizationLevel,
-            UFixedLib.toUFixed(1), // retentionLevel,
-            FeeLib.zero(), // initialPoolFee,
-            FeeLib.zero(), // initialStakingFee,
-            FeeLib.zero() // initialPerformanceFee,
-        );
-    }
-
-    // Internals
-
+    /// @dev Creates a new bundle using the provided parameter values.
     function _createBundle(
         address bundleOwner,
         Fee memory fee,
@@ -285,6 +296,7 @@ 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));

package/contracts/pool/PoolService.sol

@@ -15,8 +15,8 @@ import {INftOwnable} from "../shared/INftOwnable.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} from "../type/ObjectType.sol";
-import {PUBLIC_ROLE, POOL_OWNER_ROLE, POLICY_SERVICE_ROLE, RoleId} from "../type/RoleId.sol";
+import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY, STAKING} from "../type/ObjectType.sol";
+import {RoleId, PUBLIC_ROLE} from "../type/RoleId.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {Version, VersionLib} from "../type/Version.sol";
 import {KEEP_STATE, StateId} from "../type/StateId.sol";
@@ -28,13 +28,13 @@ import {Version, VersionLib} from "../type/Version.sol";
 
 import {IService} from "../shared/IService.sol";
 import {Service} from "../shared/Service.sol";
-import {BundleManager} from "../instance/BundleManager.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IComponentService} from "../shared/IComponentService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPoolService} from "./IPoolService.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IStaking} from "../staking/IStaking.sol";
 import {InstanceService} from "../instance/InstanceService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
@@ -55,6 +55,8 @@ contract PoolService is
     IInstanceService private _instanceService;
     IRegistryService private _registryService;
 
+    IStaking private _staking;
+
     function _initialize(
         address owner, 
         bytes memory data
@@ -76,11 +78,9 @@ contract PoolService is
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
-        registerInterface(type(IPoolService).interfaceId);
-    }
+        _staking = IStaking(getRegistry().getStakingAddress());
 
-    function getDomain() public pure override returns(ObjectType) {
-        return POOL();
+        registerInterface(type(IPoolService).interfaceId);
     }
 
 
@@ -218,13 +218,14 @@ contract PoolService is
         emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
     }
 
+
     function processSale(
         NftId bundleNftId, 
         IPolicy.Premium memory premium 
     ) 
         external
         virtual
-        restricted
+        restricted()
     {
         IRegistry registry = getRegistry();
         IRegistry.ObjectInfo memory bundleObjectInfo = registry.getObjectInfo(bundleNftId);
@@ -253,6 +254,7 @@ contract PoolService is
 
     function lockCollateral(
         IInstance instance, 
+        address token,
         NftId productNftId,
         NftId applicationNftId,
         NftId bundleNftId,
@@ -281,6 +283,12 @@ contract PoolService is
             bundleNftId,
             localCollateralAmount);
 
+        // update value locked with staking service
+        _staking.increaseTotalValueLocked(
+            instance.getNftId(),
+            token,
+            totalCollateralAmount);
+
         // hierarhical riskpool setup
         // TODO loop in with pool component to guarantee availability of external capital
         if(totalCollateralAmount > localCollateralAmount) {
@@ -291,19 +299,26 @@ contract PoolService is
 
     function reduceCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo,
         Amount payoutAmount
     )
         external
         virtual
-        restricted
+        restricted()
     {
         _bundleService.releaseCollateral(
             instance, 
             policyNftId, 
             policyInfo.bundleNftId, 
             payoutAmount);
+
+        // update value locked with staking service
+        _staking.decreaseTotalValueLocked(
+            instance.getNftId(),
+            token,
+            payoutAmount);
     }
 
 
@@ -311,22 +326,31 @@ contract PoolService is
     /// may only be called by the policy service for unlocked pool components
     function releaseCollateral(
         IInstance instance, 
+        address token,
         NftId policyNftId, 
         IPolicy.PolicyInfo memory policyInfo
     )
         external
         virtual
-        restricted
+        restricted()
     {
+        Amount remainingCollateralAmount = policyInfo.sumInsuredAmount - policyInfo.claimAmount;
+
         _bundleService.releaseCollateral(
             instance, 
             policyNftId, 
             policyInfo.bundleNftId, 
-            policyInfo.sumInsuredAmount - policyInfo.claimAmount);
+            remainingCollateralAmount);
 
         _bundleService.unlinkPolicy(
             instance, 
             policyNftId);
+
+        // update value locked with staking service
+        _staking.decreaseTotalValueLocked(
+            instance.getNftId(),
+            token,
+            remainingCollateralAmount);
     }
 
 
@@ -421,4 +445,7 @@ contract PoolService is
         }
     }
 
+    function _getDomain() internal pure override returns(ObjectType) {
+        return POOL();
+    }
 }

package/contracts/product/ApplicationService.sol

@@ -80,11 +80,6 @@ contract ApplicationService is
     }
 
 
-    function getDomain() public pure override returns(ObjectType) {
-        return APPLICATION();
-    }
-
-
     function _checkLinkedpplicationParameters(
         InstanceReader instanceReader,
         NftId productNftId,
@@ -251,4 +246,9 @@ contract ApplicationService is
     }
 
     // internal functions
+
+
+    function _getDomain() internal pure override returns(ObjectType) {
+        return APPLICATION();
+    }
 }