@etherisc/gif-next 0.0.2-f36fd21-685 → 0.0.2-f3b4c66-505

package/contracts/pool/PoolService.sol

@@ -1,42 +1,44 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IAccountingService} from "../accounting/IAccountingService.sol";
+import {IBundle} from "../instance/module/IBundle.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 {IPolicyHolder} from "../shared/IPolicyHolder.sol";
+import {IPoolComponent} from "../pool/IPoolComponent.sol";
 import {IPoolService} from "./IPoolService.sol";
+import {IProductComponent} from "../product/IProductComponent.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} 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 {ClaimId} from "../type/ClaimId.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {InstanceReader} from "../instance/InstanceReader.sol";
+import {InstanceStore} from "../instance/InstanceStore.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
-import {Seconds} from "../type/Seconds.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, ACCOUNTING, POOL, BUNDLE, PRODUCT, POLICY, COMPONENT} from "../type/ObjectType.sol";
+import {PayoutId} from "../type/PayoutId.sol";
+import {PoolLib} from "./PoolLib.sol";
+import {Service} from "../shared/Service.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {UFixed} from "../type/UFixed.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {InstanceStore} from "../instance/InstanceStore.sol";
 
 string constant POOL_SERVICE_NAME = "PoolService";
 
+
 contract PoolService is 
-    ComponentVerifyingService, 
+    Service, 
     IPoolService 
 {
+    IAccountingService private _accountingService;
     IBundleService internal _bundleService;
     IComponentService internal _componentService;
-    IInstanceService private _instanceService;
-    IRegistryService private _registryService;
-
     IStaking private _staking;
 
     function _initialize(
@@ -44,191 +46,321 @@ contract PoolService is
         bytes memory data
     )
         internal
-        initializer
         virtual override
+        initializer()
     {
         (
-            address registryAddress,, 
-            //address managerAddress
-            address authority
-        ) = abi.decode(data, (address, address, address));
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, authority, owner);
+        __Service_init(authority, registry, owner);
 
-        _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _bundleService = IBundleService(_getServiceAddress(BUNDLE()));
-        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
         _componentService = IComponentService(_getServiceAddress(COMPONENT()));
-
         _staking = IStaking(getRegistry().getStakingAddress());
 
-        registerInterface(type(IPoolService).interfaceId);
+        _registerInterface(type(IPoolService).interfaceId);
     }
 
 
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    /// @inheritdoc IPoolService
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
         virtual
     {
-        /*
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
         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;
-
-        poolInfo.maxCapitalAmount = maxCapitalAmount;
+        Amount previousMaxBalanceAmount = poolInfo.maxBalanceAmount;
+        poolInfo.maxBalanceAmount = maxBalanceAmount;
         instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
 
-        emit LogPoolServiceMaxCapitalAmountUpdated(poolNftId, previousMaxCapitalAmount, maxCapitalAmount);
-        */
+        emit LogPoolServiceMaxBalanceAmountUpdated(poolNftId, previousMaxBalanceAmount, maxBalanceAmount);
     }
 
-    function setBundleOwnerRole(RoleId bundleOwnerRole)
+
+    function closeBundle(NftId bundleNftId)
         external
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
+        _checkNftType(bundleNftId, BUNDLE());
 
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        IComponents.PoolInfo memory poolInfo = abi.decode(componentInfo.data, (IComponents.PoolInfo));
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
 
-        // bundle owner role may only be set once per pool
-        if(poolInfo.bundleOwnerRole != PUBLIC_ROLE()) {
-            revert ErrorPoolServiceBundleOwnerRoleAlreadySet(poolNftId);
-        }
+        // TODO get performance fee for pool (#477)
 
-        poolInfo.bundleOwnerRole = bundleOwnerRole;
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
+        // releasing collateral in bundle
+        (Amount unstakedAmount, Amount feeAmount) = _bundleService.close(instance, bundleNftId);
 
-        emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
+        _accountingService.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.pushToken(
+                getRegistry().ownerOf(bundleNftId), 
+                unstakedAmount + feeAmount);
+        }
     }
 
 
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
+    /// @inheritdoc IPoolService
+    function processFundedClaim(
+        NftId policyNftId, 
+        ClaimId claimId, 
+        Amount availableAmount
+    ) 
         external
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        _checkNftType(policyNftId, POLICY());
 
-        IComponents.PoolInfo memory poolInfo = instance.getInstanceReader().getPoolInfo(poolNftId);
-        poolInfo.poolFee = poolFee;
-        poolInfo.stakingFee = stakingFee;
-        poolInfo.performanceFee = performanceFee;
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
+        InstanceReader instanceReader = instance.getInstanceReader();
+        NftId productNftId = getRegistry().getParentNftId(poolNftId);
+
+        // check policy matches with calling pool
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
+        if(policyInfo.productNftId != productNftId) {
+            revert ErrorPoolServicePolicyPoolMismatch(
+                policyNftId, 
+                policyInfo.productNftId, 
+                productNftId);
+        }
 
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
+        emit LogPoolServiceProcessFundedClaim(policyNftId, claimId, availableAmount);
 
-        // TODO add logging
+        // callback to product component if applicable
+        if (instanceReader.getProductInfo(productNftId).isProcessingFundedClaims) {
+            address productAddress = getRegistry().getObjectAddress(productNftId);
+            IProductComponent(productAddress).processFundedClaim(policyNftId, claimId, availableAmount);
+        }
     }
 
-    function createBundle(
-        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
-    )
+
+    // function _checkAndGetPoolInfo(NftId bundleNftId)
+    //     internal
+    //     view
+    //     returns (
+    //         InstanceReader instanceReader,
+    //         InstanceStore instanceStore,
+    //         NftId instanceNftId,
+    //         NftId poolNftId,
+    //         IComponents.PoolInfo memory poolInfo
+    //     )
+    // {
+    //     _checkNftType(bundleNftId, BUNDLE());
+
+    //     (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
+    //     instanceReader = instance.getInstanceReader();
+    //     instanceStore = instance.getInstanceStore();
+    //     instanceNftId = instance.getNftId();
+    //     poolInfo = instanceReader.getPoolInfo(poolNftId);
+
+    //     if (getRegistry().getParentNftId(bundleNftId) != poolNftId) {
+    //         revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
+    //     }
+    // }
+
+
+    /// @inheritdoc IPoolService
+    function stake(NftId bundleNftId, Amount amount) 
         external 
         virtual
-        returns(NftId bundleNftId)
+        // TODO: restricted() (once #462 is done)
+        returns(
+            Amount netAmount
+        ) 
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
-
         (
-            Amount stakingFeeAmount,
-            Amount stakingNetAmount
-        ) = FeeLib.calculateFee(
-            _getStakingFee(instanceReader, poolNftId), 
-            stakingAmount);
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+            IComponents.PoolInfo memory poolInfo
+        ) = PoolLib.checkAndGetPoolInfo(getRegistry(), msg.sender, bundleNftId);
+
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
+        }
 
-        bundleNftId = _bundleService.create(
-            instance,
+        // calculate fees
+        Amount feeAmount;
+        (
+            feeAmount,
+            netAmount
+        ) = PoolLib.calculateStakingAmounts(
+            getRegistry(),
+            instanceReader,
             poolNftId,
-            bundleOwner,
-            fee,
-            stakingNetAmount,
-            lifetime,
-            filter);
-
-        // pool book keeping
-        _componentService.increasePoolBalance(
-            instance.getInstanceStore(), 
-            poolNftId, 
-            stakingAmount, 
-            stakingFeeAmount);
+            amount);
 
-        // pool bookkeeping and collect tokens from bundle owner
-        _collectStakingAmount(
-            instanceReader, 
+        // do all the book keeping
+        _accountingService.increasePoolBalance(
+            instanceStore, 
             poolNftId, 
-            bundleOwner, 
-            stakingAmount);
+            netAmount, 
+            feeAmount);
 
-        emit LogPoolServiceBundleCreated(instance.getNftId(), poolNftId, bundleNftId);
+        _bundleService.stake(instanceReader, instanceStore, bundleNftId, netAmount);
+
+        emit LogPoolServiceBundleStaked(instanceNftId, poolNftId, bundleNftId, amount, netAmount);
+
+        // only collect staking amount when pool is not externally managed
+        if (!poolInfo.isExternallyManaged) {
+
+            // collect tokens from bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            _pullStakingAmount(
+                instanceReader,
+                poolNftId, 
+                bundleOwner, 
+                amount);
+        }
     }
 
-    function _getStakingFee(InstanceReader instanceReader, NftId poolNftId)
-        internal
+
+    /// @inheritdoc IPoolService
+    function unstake(NftId bundleNftId, Amount amount) 
+        external 
         virtual
-        view
-        returns (Fee memory stakingFee)
+        // TODO: restricted() (once #462 is done)
+        returns(Amount netAmount) 
     {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).stakingFee;
+        (
+            InstanceReader instanceReader,
+            InstanceStore instanceStore,
+            NftId instanceNftId,
+            NftId poolNftId,
+        ) = PoolLib.checkAndGetPoolInfo(getRegistry(), msg.sender, bundleNftId);
+
+        // call bundle service for bookkeeping and additional checks
+        Amount unstakedAmount = _bundleService.unstake(instanceStore, 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)
+        netAmount = unstakedAmount;
+
+        // update pool bookkeeping - performance fees stay in the pool, but as fees 
+        _accountingService.decreasePoolBalance(
+            instanceStore, 
+            poolNftId, 
+            unstakedAmount, 
+            AmountLib.zero());
+
+
+        emit LogPoolServiceBundleUnstaked(instanceNftId, poolNftId, bundleNftId, unstakedAmount, netAmount);
+
+        // only distribute staking amount when pool is not externally managed
+        if (!instanceReader.getPoolInfo(poolNftId).isExternallyManaged) {
+
+            // transfer amount to bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            _pushUnstakingAmount(
+                instanceReader,
+                poolNftId, 
+                bundleOwner, 
+                netAmount);
+        }
     }
 
-    function closeBundle(NftId bundleNftId)
+
+    function fundPoolWallet(Amount amount)
         external
         virtual
+        // restricted()
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (
+            NftId poolNftId,
+            IInstance instance
+        ) = _getAndVerifyActivePool();
+
+        // check that pool is externally managed
+        InstanceReader reader = instance.getInstanceReader();
+        if (!reader.getPoolInfo(poolNftId).isExternallyManaged) {
+            revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
+        }
 
-        // TODO book keeping for pool collateral released outside of retention level
+        address poolOwner = getRegistry().ownerOf(poolNftId);
+        emit LogPoolServiceWalletFunded(poolNftId, poolOwner, amount);
 
-        // releasing collateral in bundle
-        _bundleService.close(instance, bundleNftId);
+        _pullStakingAmount(
+            reader,
+            poolNftId, 
+            poolOwner, 
+            amount);
+    }
 
-        // TODO get performance fee for pool, transfer of remaining funds + bundle fees to bundle owner
 
-        emit LogPoolServiceBundleClosed(instance.getNftId(), poolNftId, bundleNftId);
+    function defundPoolWallet(Amount amount)
+        external
+        virtual
+        // restricted()
+    {
+        (
+            NftId poolNftId,
+            IInstance instance
+        ) = _getAndVerifyActivePool();
+
+        // check that pool is externally managed
+        InstanceReader reader = instance.getInstanceReader();
+        if (!reader.getPoolInfo(poolNftId).isExternallyManaged) {
+            revert ErrorPoolServicePoolNotExternallyManaged(poolNftId);
+        }
+
+        address poolOwner = getRegistry().ownerOf(poolNftId);
+        emit LogPoolServiceWalletDefunded(poolNftId, poolOwner, amount);
+
+        _pushUnstakingAmount(
+            reader,
+            poolNftId, 
+            poolOwner, 
+            amount);
     }
 
 
     function processSale(
         NftId bundleNftId, 
-        IPolicy.Premium memory premium 
+        IPolicy.PremiumInfo memory premium 
     ) 
         external
         virtual
         restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
+
         IRegistry registry = getRegistry();
-        IRegistry.ObjectInfo memory bundleObjectInfo = registry.getObjectInfo(bundleNftId);
-        IRegistry.ObjectInfo memory poolObjectInfo = registry.getObjectInfo(bundleObjectInfo.parentNftId);
-        IRegistry.ObjectInfo memory instanceObjectInfo = registry.getObjectInfo(poolObjectInfo.parentNftId);
-        IInstance instance = IInstance(instanceObjectInfo.objectAddress);
+        NftId poolNftId = registry.getParentNftId(bundleNftId);
+        (, address instanceAddress) = ContractLib.getInfoAndInstance(registry, poolNftId, true);
+        IInstance instance = IInstance(instanceAddress);
 
-        Amount poolFeeAmount = AmountLib.toAmount(premium.poolFeeFixAmount + premium.poolFeeVarAmount);
-        Amount bundleFeeAmount = AmountLib.toAmount(premium.bundleFeeFixAmount + premium.bundleFeeVarAmount);
-        Amount bundleNetAmount = AmountLib.toAmount(premium.netPremiumAmount);
+        Amount poolFeeAmount = premium.poolFeeFixAmount + premium.poolFeeVarAmount;
+        Amount bundleFeeAmount = premium.bundleFeeFixAmount + premium.bundleFeeVarAmount;
+        Amount bundleNetAmount = premium.netPremiumAmount;
 
         InstanceStore instanceStore = instance.getInstanceStore();
-        _componentService.increasePoolBalance(
+        _accountingService.increasePoolBalance(
             instanceStore,
-            poolObjectInfo.nftId,
+            poolNftId,
             bundleNetAmount + bundleFeeAmount, 
             poolFeeAmount);
 
-        _componentService.increaseBundleBalance(
+        _accountingService.increaseBundleBalanceForPool(
             instanceStore,
-            bundleObjectInfo.nftId,
+            bundleNftId,
             bundleNetAmount, 
             bundleFeeAmount);
     }
@@ -246,14 +378,22 @@ contract PoolService is
         virtual
         restricted()
         returns (
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
+            Amount totalCollateralAmount,
+            Amount localCollateralAmount
         )
     {
+        _checkNftType(productNftId, PRODUCT());
+        _checkNftType(applicationNftId, POLICY());
+        _checkNftType(bundleNftId, BUNDLE());
+
+        NftId poolNftId;
+        bool poolIsVerifyingApplications;
         (
+            poolNftId,
+            totalCollateralAmount,
             localCollateralAmount,
-            totalCollateralAmount
-        ) = calculateRequiredCollateral(
+            poolIsVerifyingApplications
+        ) = PoolLib.calculateRequiredCollateral(
             instance.getInstanceReader(),
             productNftId, 
             sumInsuredAmount);
@@ -271,36 +411,172 @@ contract PoolService is
             token,
             totalCollateralAmount);
 
-        // hierarhical riskpool setup
-        // TODO loop in with pool component to guarantee availability of external capital
-        if(totalCollateralAmount > localCollateralAmount) {
+        // pool callback when required
+        if (poolIsVerifyingApplications) {
+            IPoolComponent pool = IPoolComponent(
+                getRegistry().getObjectAddress(poolNftId));
 
+            pool.verifyApplication(
+                applicationNftId, 
+                bundleNftId, 
+                totalCollateralAmount);
+
+            // TODO add logging
         }
-    }
 
+        // TODO add logging
+    }
 
-    function reduceCollateral(
-        IInstance instance, 
-        address token,
+    function processPayout(
+        InstanceReader instanceReader,
+        InstanceStore instanceStore, 
+        NftId productNftId,
         NftId policyNftId, 
-        IPolicy.PolicyInfo memory policyInfo,
-        Amount payoutAmount
+        NftId bundleNftId,
+        PayoutId payoutId,
+        Amount payoutAmount,
+        address payoutBeneficiary
     )
         external
         virtual
         restricted()
     {
+        // checks
+        _checkNftType(policyNftId, POLICY());
+
+        // effects
+        NftId poolNftId = getRegistry().getParentNftId(bundleNftId);
+        
+        _accountingService.decreasePoolBalance(
+            instanceStore,
+            poolNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
+        _accountingService.decreaseBundleBalanceForPool(
+            instanceStore,
+            bundleNftId,
+            payoutAmount, 
+            AmountLib.zero());
+
         _bundleService.releaseCollateral(
-            instance, 
+            instanceStore, 
             policyNftId, 
-            policyInfo.bundleNftId, 
+            bundleNftId, 
             payoutAmount);
 
         // update value locked with staking service
+        TokenHandler poolTokenHandler = TokenHandler(
+            instanceReader.getTokenHandler(
+                poolNftId));
+
         _staking.decreaseTotalValueLocked(
-            instance.getNftId(),
-            token,
+            instanceReader.getInstanceNftId(), 
+            address(poolTokenHandler.TOKEN()),
             payoutAmount);
+
+        // interactions
+        _transferTokenAndNotifyPolicyHolder(
+            instanceReader, 
+            poolTokenHandler,
+            productNftId, 
+            policyNftId, 
+            payoutId, 
+            payoutAmount, 
+            payoutBeneficiary);
+    }
+
+    function _transferTokenAndNotifyPolicyHolder(
+        InstanceReader instanceReader,
+        TokenHandler poolTokenHandler,
+        NftId productNftId,
+        NftId policyNftId,
+        PayoutId payoutId,
+        Amount payoutAmount,
+        address payoutBeneficiary
+    )
+        internal
+    {
+        (
+            Amount netPayoutAmount,
+            Amount processingFeeAmount,
+            address beneficiary
+        ) = PoolLib.calculatePayoutAmounts(
+            getRegistry(),
+            instanceReader,
+            productNftId, 
+            policyNftId,
+            payoutAmount,
+            payoutBeneficiary);
+
+        // 1st token tx to payout to beneficiary
+        poolTokenHandler.pushToken(
+            beneficiary, 
+            netPayoutAmount);
+
+        // 2nd token tx to transfer processing fees to product wallet
+        // if processingFeeAmount > 0
+        if (processingFeeAmount.gtz()) {
+            poolTokenHandler.pushToken(
+                instanceReader.getWallet(productNftId), 
+                processingFeeAmount);
+        }
+
+        // callback to policy holder if applicable
+        _policyHolderPayoutExecuted(
+            policyNftId, 
+            payoutId, 
+            beneficiary, 
+            netPayoutAmount);
+    }
+
+
+    /// @inheritdoc IPoolService
+    function withdrawBundleFees(
+        NftId bundleNftId,
+        Amount amount
+    ) 
+        public 
+        virtual
+        restricted()
+        returns (Amount withdrawnAmount) 
+    {
+        // checks
+        _checkNftType(bundleNftId, BUNDLE());
+
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActivePool();
+        InstanceReader reader = instance.getInstanceReader();
+        
+        // determine withdrawn amount
+        withdrawnAmount = amount;
+        if (withdrawnAmount.gte(AmountLib.max())) {
+            withdrawnAmount = reader.getFeeAmount(bundleNftId);
+        } else {
+            if (withdrawnAmount > reader.getFeeAmount(bundleNftId)) {
+                revert ErrorPoolServiceFeesWithdrawAmountExceedsLimit(withdrawnAmount, reader.getFeeAmount(bundleNftId));
+            }
+        }
+
+        // effects
+        // decrease fee counters by withdrawnAmount
+        {
+            InstanceStore store = instance.getInstanceStore();
+            // decrease fee amount of the bundle
+            _accountingService.decreaseBundleBalanceForPool(store, bundleNftId, AmountLib.zero(), withdrawnAmount);
+            // decrease pool balance 
+            _accountingService.decreasePoolBalance(store, poolNftId, withdrawnAmount, AmountLib.zero());
+        }
+
+        // interactions
+        // transfer amount to bundle owner
+        {
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            TokenHandler tokenHandler = reader.getTokenHandler(poolNftId);
+            address token = address(tokenHandler.TOKEN());
+            emit LogPoolServiceFeesWithdrawn(bundleNftId, bundleOwner, token, withdrawnAmount);
+
+            tokenHandler.pushToken(bundleOwner, withdrawnAmount);
+        }
     }
 
 
@@ -308,7 +584,6 @@ 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
     )
@@ -316,117 +591,165 @@ contract PoolService is
         virtual
         restricted()
     {
+        _checkNftType(policyNftId, POLICY());
+
         Amount remainingCollateralAmount = policyInfo.sumInsuredAmount - policyInfo.claimAmount;
 
         _bundleService.releaseCollateral(
-            instance, 
+            instance.getInstanceStore(), 
             policyNftId, 
             policyInfo.bundleNftId, 
             remainingCollateralAmount);
 
-        _bundleService.unlinkPolicy(
-            instance, 
-            policyNftId);
-
         // update value locked with staking service
+        InstanceReader instanceReader = instance.getInstanceReader();
         _staking.decreaseTotalValueLocked(
-            instance.getNftId(),
-            token,
+            instanceReader.getInstanceNftId(),
+            address(instanceReader.getToken(policyInfo.productNftId)),
             remainingCollateralAmount);
     }
 
 
-    function calculateRequiredCollateral(
-        InstanceReader instanceReader,
-        NftId productNftId, 
-        Amount sumInsuredAmount
+    // function calculateRequiredCollateral(
+    //     InstanceReader instanceReader,
+    //     NftId productNftId, 
+    //     Amount sumInsuredAmount
+    // )
+    //     public
+    //     view 
+    //     returns(
+    //         NftId poolNftId,
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount,
+    //         bool poolIsVerifyingApplications
+    //     )
+    // {
+    //     return CollateralLib.calculateRequiredCollateral(
+    //         instanceReader,
+    //         productNftId, 
+    //         sumInsuredAmount);
+    // }
+
+    //     _checkNftType(productNftId, PRODUCT());
+
+    //     poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
+    //     IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+    //     poolIsVerifyingApplications = poolInfo.isVerifyingApplications;
+
+    //     (
+    //         totalCollateralAmount,
+    //         localCollateralAmount
+    //     ) = calculateRequiredCollateral(
+    //         poolInfo.collateralizationLevel,
+    //         poolInfo.retentionLevel,
+    //         sumInsuredAmount);
+    // }
+
+
+    // function calculateRequiredCollateral(
+    //     UFixed collateralizationLevel, 
+    //     UFixed retentionLevel, 
+    //     Amount sumInsuredAmount
+    // )
+    //     public
+    //     pure 
+    //     returns(
+    //         Amount totalCollateralAmount,
+    //         Amount localCollateralAmount
+    //     )
+    // {
+    //     // collateralization is applied to sum insured
+    //     UFixed totalUFixed = collateralizationLevel * sumInsuredAmount.toUFixed();
+    //     totalCollateralAmount = AmountLib.toAmount(totalUFixed.toInt());
+
+    //     // retention level defines how much capital is required locally
+    //     localCollateralAmount = AmountLib.toAmount(
+    //         (retentionLevel * totalUFixed).toInt());
+    // }
+
+
+
+
+    function _policyHolderPayoutExecuted(
+        NftId policyNftId, 
+        PayoutId payoutId,
+        address beneficiary,
+        Amount payoutAmount
     )
-        public
-        view 
-        returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
-        )
+        internal
     {
-        NftId poolNftId = instanceReader.getProductInfo(productNftId).poolNftId;
-        IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
-
-        (
-            localCollateralAmount,
-            totalCollateralAmount
-        ) = calculateRequiredCollateral(
-            poolInfo.collateralizationLevel,
-            poolInfo.retentionLevel,
-            sumInsuredAmount);
+        IPolicyHolder policyHolder = PoolLib.getPolicyHolder(getRegistry(), policyNftId);
+        if(address(policyHolder) != address(0)) {
+            policyHolder.payoutExecuted(policyNftId, payoutId, payoutAmount, beneficiary);
+        }
     }
 
 
-    function calculateRequiredCollateral(
-        UFixed collateralizationLevel, 
-        UFixed retentionLevel, 
-        Amount sumInsuredAmount
+    /// @dev Transfers the specified amount from the "from account" to the pool's wallet
+    function _pullStakingAmount(
+        InstanceReader reader,
+        NftId poolNftId,
+        address from,
+        Amount amount
     )
-        public
-        pure 
-        returns(
-            Amount localCollateralAmount,
-            Amount totalCollateralAmount
-        )
+        internal
     {
-        // TODO define if only applies to local collateral
-        // TODO add minimalistic implementation
-
-        // assumptions 
-        // - collateralizationLevel == 1.0
-        // - retentionLevel == 1.0
-        localCollateralAmount = sumInsuredAmount;
-        totalCollateralAmount = localCollateralAmount;
+        IComponents.ComponentInfo memory info = reader.getComponentInfo(poolNftId);
+        info.tokenHandler.pullToken(
+            from,
+            amount);
     }
 
-
-    function _processStakingFees(
-        Fee memory stakingFee, 
-        Amount stakingAmount
+    /// @dev Transfers the specified amount from the pool's wallet to the "to account"
+    function _pushUnstakingAmount(
+        InstanceReader reader,
+        NftId poolNftId,
+        address to,
+        Amount amount
     )
         internal
-        returns (Amount stakingNetAmount)
     {
-        stakingNetAmount = stakingAmount;
-
-        // check if any staking fees apply
-        if (FeeLib.gtz(stakingFee)) {
-            (Amount feeAmount, Amount netAmount) = FeeLib.calculateFee(stakingFee, stakingAmount);
-            stakingNetAmount = netAmount;
-
-            // TODO update fee balance for pool
-        }
+        IComponents.ComponentInfo memory info = reader.getComponentInfo(poolNftId);
+        info.tokenHandler.pushToken(
+            to, 
+            amount);
     }
 
 
-    // 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 _collectStakingAmount(
-        InstanceReader instanceReader,
-        NftId poolNftId,
-        address bundleOwner,
-        Amount amount
-    )
+    function _getAndVerifyActivePool()
         internal
+        virtual
+        view
+        returns (
+            NftId poolNftId,
+            IInstance instance
+        )
     {
+        return PoolLib.getAndVerifyActivePool(getRegistry(), msg.sender);
+    }
 
-        // collecting investor token
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(poolNftId);
-        TokenHandler tokenHandler = componentInfo.tokenHandler;
-        address poolWallet = componentInfo.wallet;
+    // function _getAndVerifyActivePool()
+    //     internal
+    //     virtual
+    //     view
+    //     returns (
+    //         NftId poolNftId,
+    //         IInstance instance
+    //     )
+    // {
+    //     (
+    //         IRegistry.ObjectInfo memory info, 
+    //         address instanceAddress
+    //     ) = ContractLib.getAndVerifyComponent(
+    //         getRegistry(), 
+    //         msg.sender,
+    //         POOL(),
+    //         true); // only active pools
+
+    //     poolNftId = info.nftId;
+    //     instance = IInstance(instanceAddress);
+    // }
 
-        if(amount.gtz()) {
-            // TODO: centralize token handling (issue #471)
-            tokenHandler.transfer(
-                bundleOwner,
-                poolWallet,
-                amount);
-        }
-    }
 
     function _getDomain() internal pure override returns(ObjectType) {
         return POOL();