@etherisc/gif-next 0.0.2-d5fac82-078 → 0.0.2-d62f29e-108

package/contracts/pool/PoolService.sol

@@ -1,52 +1,43 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-import {Pool} from "./Pool.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {IInstance} from "../instance/IInstance.sol";
 import {IBundle} from "../instance/module/IBundle.sol";
-import {TokenHandler} from "../instance/module/ITreasury.sol";
+import {IBundleService} from "./IBundleService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
+import {IComponentService} from "../shared/IComponentService.sol";
+import {IInstance} from "../instance/IInstance.sol";
+import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPolicy} from "../instance/module/IPolicy.sol";
-
-import {IVersionable} from "../shared/IVersionable.sol";
-import {Versionable} from "../shared/Versionable.sol";
-import {INftOwnable} from "../shared/INftOwnable.sol";
+import {IPoolService} from "./IPoolService.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IRegistryService} from "../registry/IRegistryService.sol";
+import {IStaking} from "../staking/IStaking.sol";
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
-import {NftId, NftIdLib, zeroNftId} from "../type/NftId.sol";
-import {ObjectType, POOL, BUNDLE} from "../type/ObjectType.sol";
-import {PUBLIC_ROLE, POOL_OWNER_ROLE, POLICY_SERVICE_ROLE, RoleId} from "../type/RoleId.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, POOL, BUNDLE, COMPONENT, INSTANCE, REGISTRY} 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";
+import {KEEP_STATE} from "../type/StateId.sol";
 import {Seconds} from "../type/Seconds.sol";
-import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-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 {ComponentService} from "../shared/ComponentService.sol";
-import {IBundleService} from "./IBundleService.sol";
-import {IPoolService} from "./IPoolService.sol";
-import {IRegistryService} from "../registry/IRegistryService.sol";
-import {InstanceService} from "../instance/InstanceService.sol";
+import {UFixed} from "../type/UFixed.sol";
+import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IComponent} from "../shared/IComponent.sol";
-import {IPoolComponent} from "./IPoolComponent.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
 
 string constant POOL_SERVICE_NAME = "PoolService";
 
 contract PoolService is 
-    ComponentService, 
+    ComponentVerifyingService, 
     IPoolService 
 {
-    using NftIdLib for NftId;
-    using AmountLib for Amount;
-
     IBundleService internal _bundleService;
+    IComponentService internal _componentService;
+    IInstanceService private _instanceService;
+    IRegistryService private _registryService;
+
+    IStaking private _staking;
 
     function _initialize(
         address owner, 
@@ -63,85 +54,38 @@ contract PoolService is
         ) = abi.decode(data, (address, address, address));
 
         initializeService(registryAddress, authority, owner);
-        _bundleService = IBundleService(getRegistry().getServiceAddress(BUNDLE(), getVersion().toMajorPart()));
-        registerInterface(type(IPoolService).interfaceId);
-    }
 
-    function getDomain() public pure override returns(ObjectType) {
-        return POOL();
-    }
+        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+        _bundleService = IBundleService(_getServiceAddress(BUNDLE()));
+        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
+        _componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
-    function register(address poolAddress) 
-        external
-        returns(NftId poolNftId)
-    {
-        (
-            IComponent component,
-            address owner,
-            IInstance instance,
-            NftId instanceNftId
-        ) = _checkComponentForRegistration(
-            poolAddress,
-            POOL(),
-            POOL_OWNER_ROLE());
-
-        IPoolComponent pool = IPoolComponent(poolAddress);
-        IRegistry.ObjectInfo memory registryInfo = getRegistryService().registerPool(pool, owner);
-        pool.linkToRegisteredNftId();
-        poolNftId = registryInfo.nftId;
-
-        // amend component info with pool specific token handler
-        IComponents.ComponentInfo memory componentInfo = pool.getComponentInfo();
-        componentInfo.tokenHandler = new TokenHandler(address(componentInfo.token));
-
-        // save amended component info with instance
-        instance.getInstanceStore().createPoolSetup(poolNftId, componentInfo);
-
-        bytes4[][] memory selectors = new bytes4[][](2);
-        selectors[0] = new bytes4[](1);
-        selectors[1] = new bytes4[](1);
-
-        selectors[0][0] = IPoolComponent.setFees.selector;
-        selectors[1][0] = IPoolComponent.verifyApplication.selector;
-
-        RoleId[] memory roles = new RoleId[](2);
-        roles[0] = POOL_OWNER_ROLE();
-        roles[1] = POLICY_SERVICE_ROLE();
-
-        getInstanceService().createGifTarget(
-            instanceNftId, 
-            poolAddress, 
-            pool.getName(), 
-            selectors, 
-            roles);
-    }
+        _staking = IStaking(getRegistry().getStakingAddress());
 
+        registerInterface(type(IPoolService).interfaceId);
+    }
 
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    /// @inheritdoc IPoolService
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
         virtual
     {
-        /*
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
 
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-        Amount previousMaxCapitalAmount = poolInfo.maxCapitalAmount;
+        Amount previousMaxBalanceAmount = poolInfo.maxBalanceAmount;
+        poolInfo.maxBalanceAmount = maxBalanceAmount;
+        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
-        poolInfo.maxCapitalAmount = maxCapitalAmount;
-        componentInfo.data = abi.encode(poolInfo);
-        instance.getInstanceStore().updatePoolSetup(poolNftId, componentInfo, KEEP_STATE());
-
-        emit LogPoolServiceMaxCapitalAmountUpdated(poolNftId, previousMaxCapitalAmount, maxCapitalAmount);
-        */
+        emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
     function setBundleOwnerRole(RoleId bundleOwnerRole)
         external
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         InstanceReader instanceReader = instance.getInstanceReader();
 
         IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
@@ -153,40 +97,15 @@ contract PoolService is
         }
 
         poolInfo.bundleOwnerRole = bundleOwnerRole;
-        componentInfo.data = abi.encode(poolInfo);
-        instance.getInstanceStore().updatePoolSetup(poolNftId, componentInfo, KEEP_STATE());
+        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
         emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
     }
 
-
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
-        external
-        virtual
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
-
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-
-        poolInfo.poolFee = poolFee;
-        poolInfo.stakingFee = stakingFee;
-        poolInfo.performanceFee = performanceFee;
-        componentInfo.data = abi.encode(poolInfo);
-        instance.getInstanceStore().updatePoolSetup(poolNftId, componentInfo, KEEP_STATE());
-
-        // TODO add logging
-    }
-
+    /// @inheritdoc IPoolService
     function createBundle(
-        address owner, // initial bundle owner
+        address bundleOwner, // initial bundle owner
         Fee memory fee, // fees deducted from premium that go to bundle owner
-        Amount stakingAmount, // staking amount - staking fees result in initial bundle capital
         Seconds lifetime, // initial duration for which new policies are covered
         bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
     )
@@ -194,53 +113,182 @@ contract PoolService is
         virtual
         returns(NftId bundleNftId)
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
-
-        // pool fee book keeping
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        Amount stakingNetAmount = _processStakingFees(componentInfo, stakingAmount);
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
+        // create the empty bundle
         bundleNftId = _bundleService.create(
             instance,
             poolNftId,
-            owner,
+            bundleOwner,
             fee,
-            stakingNetAmount,
+            AmountLib.zero(), 
             lifetime,
             filter);
 
-        // collect tokens from bundle owner
-        _transferStakingAmount(componentInfo, owner, stakingAmount);
-
         emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
     }
 
+    function _getStakingFee(InstanceReader instanceReader, NftId poolNftId)
+        internal
+        virtual
+        view
+        returns (Fee memory stakingFee)
+    {
+        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
+        return instanceReader.getProductInfo(productNftId).stakingFee;
+    }
 
     function closeBundle(NftId bundleNftId)
         external
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyCallingComponentAndInstance(POOL());
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
 
-        // TODO book keeping for pool collateral released outside of retention level
+        // TODO get performance fee for pool (#477)
 
         // releasing collateral in bundle
-        _bundleService.close(instance, bundleNftId);
-
-        // TODO get performance fee for pool, transfer of remaining funds + bundle fees to bundle owner
+        (Amount unstakedAmount, Amount feeAmount) = _bundleService.close(instance, bundleNftId);
 
+        _componentService.decreasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            unstakedAmount +  feeAmount, 
+            AmountLib.zero());
+        
         emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+
+        if ((unstakedAmount + feeAmount).gtz()){
+            IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolNftId);
+            poolComponentInfo.tokenHandler.distributeTokens(
+                poolComponentInfo.wallet, 
+                getRegistry().ownerOf(bundleNftId), 
+                unstakedAmount + feeAmount);
+        }
+    }
+
+    /// @inheritdoc IPoolService
+    function stake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
+        }
+
+        // calculate fees
+        Amount feeAmount;
+        (
+            feeAmount,
+            netAmount
+        ) = FeeLib.calculateFee(
+            _getStakingFee(instanceReader, poolNftId), 
+            amount);
+
+        // do all the bookkeeping
+        _componentService.increasePoolBalance(
+            instance.getInstanceStore(), 
+            poolNftId, 
+            netAmount, 
+            feeAmount);
+
+        _bundleService.stake(instance, bundleNftId, netAmount);
+
+        // collect tokens from bundle owner
+        address bundleOwner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
+
+        // TODO only collect staking token when pool is not externally managed 
+        _collectStakingAmount(
+            instanceReader, 
+            poolNftId, 
+            bundleOwner, 
+            amount);
+    }
+
+    /// @inheritdoc IPoolService
+    function unstake(NftId bundleNftId, Amount amount) 
+        external 
+        virtual
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
+    {
+        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        InstanceReader instanceReader = instance.getInstanceReader();
+        InstanceStore instanceStore = instance.getInstanceStore();
+        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
+        
+        if (bundleInfo.poolNftId != poolNftId) {
+            revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+        }
+
+        // call bundle service for bookkeeping and additional checks
+        Amount unstakedAmount = _bundleService.unstake(instance, bundleNftId, amount);
+
+        // Important: from now on work only with unstakedAmount as it is the only reliable amount.
+        // if amount was max, this was set to the available amount
+
+        // TODO: handle performance fees (issue #477)
+
+        // update pool bookkeeping - performance fees stay in the pool, but as fees 
+        _componentService.decreasePoolBalance(
+            instanceStore, 
+            poolNftId, 
+            unstakedAmount, 
+            AmountLib.zero());
+
+        IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
+        address poolWallet = poolComponentInfo.wallet;
+        // transfer amount to bundle owner
+        address owner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
+        poolComponentInfo.tokenHandler.distributeTokens(
+            poolWallet, 
+            owner, 
+            unstakedAmount);
+        return unstakedAmount;
+    }
+
+
+    function fundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        // TODO check that poolNftId is externally managed
+        // TODO implement
+    }
+
+
+    function defundPoolWallet(NftId poolNftId, Amount amount)
+        external
+        virtual
+        restricted()
+    {
+        // TODO check that poolNftId is externally managed
+        // TODO implement
     }
 
     function processSale(
         NftId bundleNftId, 
-        IPolicy.Premium memory premium, 
-        Amount actualAmountTransferred
+        IPolicy.PremiumInfo memory premium 
     ) 
         external
         virtual
-        restricted
+        restricted()
     {
         IRegistry registry = getRegistry();
         IRegistry.ObjectInfo memory bundleObjectInfo = registry.getObjectInfo(bundleNftId);
@@ -248,92 +296,92 @@ contract PoolService is
         IRegistry.ObjectInfo memory instanceObjectInfo = registry.getObjectInfo(poolObjectInfo.parentNftId);
         IInstance instance = IInstance(instanceObjectInfo.objectAddress);
 
-        Amount poolFeeAmount = AmountLib.toAmount(premium.poolFeeFixAmount + premium.poolFeeVarAmount);
-        Amount bundleFeeAmount = AmountLib.toAmount(premium.bundleFeeFixAmount + premium.bundleFeeVarAmount);
-        Amount expectedTransferAmount = AmountLib.toAmount(premium.netPremiumAmount) + poolFeeAmount + bundleFeeAmount;
-        if (!(actualAmountTransferred == expectedTransferAmount)) {
-            revert ErrorPoolServiceInvalidTransferAmount(expectedTransferAmount, actualAmountTransferred);
-        }
-        
-        // update pool fee balance
-        if (poolFeeAmount.gtz()) {
-            IComponents.ComponentInfo memory poolComponentInfo = instance.getInstanceReader().getComponentInfo(poolObjectInfo.nftId);
-            poolComponentInfo.feeAmount = poolComponentInfo.feeAmount.add(poolFeeAmount);
-            instance.getInstanceStore().updatePoolSetup(poolObjectInfo.nftId, poolComponentInfo, KEEP_STATE());
-        }
-
-        if (bundleFeeAmount.gtz()) {
-            _bundleService.updateBundleFees(instance, bundleNftId, bundleFeeAmount);
-        }
+        Amount poolFeeAmount = premium.poolFeeFixAmount + premium.poolFeeVarAmount;
+        Amount bundleFeeAmount = premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
+        Amount bundleNetAmount = premium.netPremiumAmount;
+
+        InstanceStore instanceStore = instance.getInstanceStore();
+        _componentService.increasePoolBalance(
+            instanceStore,
+            poolObjectInfo.nftId,
+            bundleNetAmount + bundleFeeAmount, 
+            poolFeeAmount);
+
+        _componentService.increaseBundleBalance(
+            instanceStore,
+            bundleObjectInfo.nftId,
+            bundleNetAmount, 
+            bundleFeeAmount);
     }
 
+
     function lockCollateral(
         IInstance instance, 
+        address token,
         NftId productNftId,
         NftId applicationNftId,
-        IPolicy.PolicyInfo memory applicationInfo,
-        Amount premiumAmount // premium amount after product and distribution fees
+        NftId bundleNftId,
+        Amount sumInsuredAmount // premium amount after product and distribution fees
     )
         external
         virtual
-        restricted
+        restricted()
+        returns (
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        )
     {
-        InstanceReader instanceReader = instance.getInstanceReader();
-        NftId poolNftId = instanceReader.getProductSetupInfo(productNftId).poolNftId;
-        NftId bundleNftId = applicationInfo.bundleNftId;
-
-        // TODO move this check to application creation and don't repeat this here
-        // ensure that pool for bundle from application matches with pool for product of application
-        IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
-        if(bundleInfo.poolNftId != poolNftId) {
-            revert ErrorPoolServiceBundlePoolMismatch(bundleInfo.poolNftId, poolNftId);
-        }
-
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
-
-        // TODO add correct required collateral calculation (collateralization level mibht be != 1, retention level might be < 1)
-        Amount collateralAmount = applicationInfo.sumInsuredAmount;
-
-        // TODO add correct net premium calculation (pool fee might be > 0)
-        Amount premiumAfterPoolFeeAmount = premiumAmount;
-
-        // lock collateral amount from involvedd bundle
+        (
+            localCollateralAmount,
+            totalCollateralAmount
+        ) = calculateRequiredCollateral(
+            instance.getInstanceReader(),
+            productNftId, 
+            sumInsuredAmount);
+
+        // lock collateral amount from involved bundle
         _bundleService.lockCollateral(
             instance,
             applicationNftId, 
             bundleNftId,
-            collateralAmount,
-            premiumAfterPoolFeeAmount);
-
-        // also verify/confirm application by pool if necessary
-        if(poolInfo.isVerifyingApplications) {
-            address poolAddress = getRegistry().getObjectInfo(poolNftId).objectAddress;
-            IPoolComponent(poolAddress).verifyApplication(
-                applicationNftId, 
-                applicationInfo.applicationData, 
-                bundleNftId,
-                bundleInfo.filter,
-                collateralAmount);
+            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) {
+
         }
     }
 
 
     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);
     }
 
 
@@ -341,27 +389,84 @@ 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);
+    }
+
+
+    function calculateRequiredCollateral(
+        InstanceReader instanceReader,
+        NftId productNftId, 
+        Amount sumInsuredAmount
+    )
+        public
+        view 
+        returns(
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        )
+    {
+        NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+        (
+            localCollateralAmount,
+            totalCollateralAmount
+        ) = calculateRequiredCollateral(
+            poolInfo.collateralizationLevel,
+            poolInfo.retentionLevel,
+            sumInsuredAmount);
+    }
+
+
+    function calculateRequiredCollateral(
+        UFixed collateralizationLevel, 
+        UFixed retentionLevel, 
+        Amount sumInsuredAmount
+    )
+        public
+        pure 
+        returns(
+            Amount localCollateralAmount,
+            Amount totalCollateralAmount
+        )
+    {
+        // TODO define if only applies to local collateral
+        // TODO add minimalistic implementation
+
+        // assumptions 
+        // - collateralizationLevel == 1.0
+        // - retentionLevel == 1.0
+        localCollateralAmount = sumInsuredAmount;
+        totalCollateralAmount = localCollateralAmount;
     }
 
 
     function _processStakingFees(
-        IComponents.ComponentInfo memory componentInfo, 
+        Fee memory stakingFee, 
         Amount stakingAmount
     )
         internal
@@ -370,7 +475,6 @@ contract PoolService is
         stakingNetAmount = stakingAmount;
 
         // check if any staking fees apply
-        Fee memory stakingFee = abi.decode(componentInfo.data, (IComponents.PoolInfo)).stakingFee;
         if (FeeLib.gtz(stakingFee)) {
             (Amount feeAmount, Amount netAmount) = FeeLib.calculateFee(stakingFee, stakingAmount);
             stakingNetAmount = netAmount;
@@ -380,25 +484,26 @@ contract PoolService is
     }
 
 
-    // TODO create (I)TreasuryService that deals with all gif related token transfers
     /// @dev transfers the specified amount from the bundle owner to the pool's wallet
-    function _transferStakingAmount(
-        IComponents.ComponentInfo memory componentInfo,
+    function _collectStakingAmount(
+        InstanceReader instanceReader,
+        NftId poolNftId,
         address bundleOwner,
-        Amount stakingAmount
+        Amount amount
     )
         internal
     {
-        TokenHandler tokenHandler = componentInfo.tokenHandler;
-        address poolWallet = componentInfo.wallet;
 
-        if(stakingAmount.gtz()) {
-            tokenHandler.transfer(
-                bundleOwner,
-                poolWallet,
-                stakingAmount
-            );
-        }
+        // collecting investor token
+        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
+        address poolWallet = componentInfo.wallet;
+        componentInfo.tokenHandler.collectTokens(
+            bundleOwner,
+            poolWallet,
+            amount);
     }
 
+    function _getDomain() internal pure override returns(ObjectType) {
+        return POOL();
+    }
 }