@etherisc/gif-next 0.0.2-7b65ccc-404 → 0.0.2-7bdd29a-841

package/contracts/instance/module/IPolicy.sol

@@ -22,7 +22,7 @@ interface IPolicy {
         uint256 netPremiumAmount;
         // fullPremium = netPremium + all fixed amounts + all variable amounts (excl commission and minDistribtuionOwnerFee variable part)
         uint256 fullPremiumAmount;
-        // premium = fullPremium - discount
+        // effective premium = fullPremium - discount 
         uint256 premiumAmount;
         uint256 productFeeFixAmount;
         uint256 poolFeeFixAmount;

package/contracts/mock/Dip.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 contract Dip is ERC20 {
 

package/contracts/pool/BasicPool.sol

@@ -108,13 +108,13 @@ abstract contract BasicPool is
     }
 
 
-    function close(NftId bundleNftId)
+    function closeBundle(NftId bundleNftId)
         public
         virtual
         restricted()
         onlyBundleOwner(bundleNftId)
     {
-        _close(bundleNftId);
+        _closeBundle(bundleNftId);
     }
 
 
@@ -131,13 +131,13 @@ abstract contract BasicPool is
     }
 
 
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         public
         virtual
         restricted()
         onlyOwner()
     {
-        _setMaxCapitalAmount(maxCapitalAmount);
+        _setMaxBalanceAmount(maxBalanceAmount);
     }
 
 

package/contracts/pool/BasicPoolAuthorization.sol

@@ -40,10 +40,10 @@ contract BasicPoolAuthorization
           _authorize(functions, BasicPool.extend.selector, "extend");
           _authorize(functions, BasicPool.lockBundle.selector, "lockBundle");
           _authorize(functions, BasicPool.unlockBundle.selector, "unlockBundle");
-          _authorize(functions, BasicPool.close.selector, "close");
+          _authorize(functions, BasicPool.closeBundle.selector, "closeBundle");
           _authorize(functions, BasicPool.setBundleFee.selector, "setBundleFee");
 
-          _authorize(functions, BasicPool.setMaxCapitalAmount.selector, "setMaxCapitalAmount");
+          _authorize(functions, BasicPool.setMaxBalanceAmount.selector, "setMaxBalanceAmount");
           _authorize(functions, BasicPool.setBundleOwnerRole.selector, "setBundleOwnerRole");
           _authorize(functions, BasicPool.setFees.selector, "setFees");
           _authorize(functions, BasicPool.stake.selector, "stake");

package/contracts/pool/BundleService.sol

@@ -16,7 +16,7 @@ import {IPolicy} from "../instance/module/IPolicy.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {BundleSet} from "../instance/BundleSet.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {Fee} from "../type/Fee.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
 import {ObjectType, COMPONENT, POOL, BUNDLE, REGISTRY} from "../type/ObjectType.sol";
@@ -113,13 +113,15 @@ contract BundleService is
         InstanceStore instanceStore = instance.getInstanceStore();
         instanceStore.createBundle(
             bundleNftId, 
-            IBundle.BundleInfo(
-                poolNftId,
-                bundleFee,
-                filter,
-                TimestampLib.blockTimestamp(),
-                TimestampLib.blockTimestamp().addSeconds(lifetime),
-                zeroTimestamp()));
+            IBundle.BundleInfo({
+                poolNftId: poolNftId,
+                fee: bundleFee,
+                filter: filter,
+                activatedAt: TimestampLib.blockTimestamp(),
+                expiredAt: TimestampLib.blockTimestamp().addSeconds(lifetime),
+                closedAt: zeroTimestamp()
+            })
+        );
 
         // bundle book keeping
         _componentService.increaseBundleBalance(
@@ -131,7 +133,6 @@ contract BundleService is
         // put bundle under bundle managemet
         BundleSet bundleManager = instance.getBundleSet();
         bundleManager.add(bundleNftId);
-
         // TODO add logging
     }
 
@@ -148,7 +149,7 @@ contract BundleService is
         restricted()
     {
         InstanceReader instanceReader = instance.getInstanceReader();
-        StateId bundleState = instanceReader.getMetadata(bundleNftId.toKey32(BUNDLE())).state;
+        StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
         IBundle.BundleInfo memory bundleInfo = instanceReader.getBundleInfo(bundleNftId);
 
         // ensure bundle is active and not yet expired
@@ -218,9 +219,9 @@ contract BundleService is
         external
         virtual
         restricted
+        returns (Amount unstakedAmount, Amount feeAmount)
     {
-        // udpate bundle state
-        instance.getInstanceStore().updateBundleState(bundleNftId, CLOSED());
+        InstanceReader instanceReader = instance.getInstanceReader();
 
         // ensure no open policies attached to bundle
         BundleSet bundleManager = instance.getBundleSet();
@@ -229,8 +230,18 @@ contract BundleService is
             revert ErrorBundleServiceBundleWithOpenPolicies(bundleNftId, openPolicies);
         }
 
-        // update set of active bundles
-        bundleManager.lock(bundleNftId);
+        {
+            // update bundle state
+            InstanceStore instanceStore = instance.getInstanceStore();
+            instanceStore.updateBundleState(bundleNftId, CLOSED());
+            bundleManager.lock(bundleNftId);
+
+            // decrease bundle counters
+            Amount balanceAmountWithFees = instanceReader.getBalanceAmount(bundleNftId);
+            feeAmount = instanceReader.getFeeAmount(bundleNftId);
+            unstakedAmount = balanceAmountWithFees - feeAmount;
+            _componentService.decreaseBundleBalance(instanceStore, bundleNftId, unstakedAmount, feeAmount);
+        }
     }
 
     /// @inheritdoc IBundleService
@@ -244,9 +255,11 @@ contract BundleService is
         // TODO: restricted() (once #462 is done)
     {
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
-        StateId bundleState = instance.getInstanceReader().getMetadata(bundleNftId.toKey32(BUNDLE())).state;
+        StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
 
-        if(bundleState != ACTIVE() || bundleInfo.expiredAt < TimestampLib.blockTimestamp() || bundleInfo.closedAt.gtz()) {
+        if( (bundleState != ACTIVE() && bundleState != PAUSED()) // locked bundles can be staked
+            || bundleInfo.expiredAt < TimestampLib.blockTimestamp() 
+            || bundleInfo.closedAt.gtz()) {
             revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
         }
 
@@ -306,7 +319,7 @@ contract BundleService is
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
         IBundle.BundleInfo memory bundleInfo = instance.getInstanceReader().getBundleInfo(bundleNftId);
-        StateId bundleState = instance.getInstanceReader().getMetadata(bundleNftId.toKey32(BUNDLE())).state;
+        StateId bundleState = instance.getInstanceReader().getBundleState(bundleNftId);
 
         // ensure bundle belongs to the pool
         if (bundleInfo.poolNftId != poolNftId) {
@@ -318,6 +331,10 @@ contract BundleService is
             revert ErrorBundleServiceBundleNotOpen(bundleNftId, bundleState, bundleInfo.expiredAt);
         }
 
+        if (lifetimeExtension.eqz()) {
+            revert ErrorBundleServiceExtensionLifetimeIsZero();
+        }
+
         bundleInfo.expiredAt = bundleInfo.expiredAt.addSeconds(lifetimeExtension);
         instance.getInstanceStore().updateBundle(bundleNftId, bundleInfo, KEEP_STATE());
 
@@ -405,10 +422,9 @@ contract BundleService is
         // transfer amount to bundle owner
         {
             address owner = getRegistry().ownerOf(bundleNftId);
+            emit LogBundleServiceFeesWithdrawn(bundleNftId, owner, address(token), withdrawnAmount);
             // TODO: centralize token handling (issue #471)
             poolInfo.tokenHandler.transfer(poolWallet, owner, withdrawnAmount);
-
-            emit LogBundleServiceFeesWithdrawn(bundleNftId, owner, address(token), withdrawnAmount);
         }
     }
 

package/contracts/pool/IBundleService.sol

@@ -26,13 +26,14 @@ interface IBundleService is IService {
 
     error ErrorBundleServicePolicyNotCloseable(NftId policyNftId);
 
-    // error ErrorBundleServiceBundleNotActive(NftId distributorNftId);
     error ErrorBundleServiceFeesWithdrawAmountExceedsLimit(Amount amount, Amount limit);
     error ErrorBundleServiceFeesWithdrawAmountIsZero();
     error ErrorBundleServiceWalletAllowanceTooSmall(address wallet, address tokenHandler, uint256 allowance, uint256 amount);
 
     error ErrorBundleServiceUnstakeAmountExceedsLimit(Amount amount, Amount limit);
 
+    error ErrorBundleServiceExtensionLifetimeIsZero();
+
     event LogBundleServiceFeesWithdrawn(NftId bundleNftId, address recipient, address tokenAddress, Amount amount);
     event LogBundleServiceBundleExtended(NftId bundleNftId, Seconds lifetimeExtension, Timestamp extendedExpiredAt);
 
@@ -51,7 +52,7 @@ interface IBundleService is IService {
         returns(NftId bundleNftId); // the nft id of the newly created bundle
 
 
-    /// @dev increase bundle stakes by the specified amount
+    /// @dev increase bundle stakes by the specified amount. bundle must not be expired or closed
     /// may only be called by the pool service
     function stake(IInstance instance, NftId bundleNftId, Amount amount) external;
 
@@ -80,10 +81,12 @@ interface IBundleService is IService {
     /// only open bundles (active or locked) may be closed
     /// to close a bundle it may not have any non-closed polices attached to it
     /// may only be called by registered and unlocked pool components
+    /// @return balanceAmount the unstaked amount that was remaining in the bundle
+    /// @return feeAmount the fee amount that was remaining for the bundle
     function close(
         IInstance instance, 
         NftId bundleNftId
-    ) external;
+    ) external returns (Amount balanceAmount, Amount feeAmount);
 
     /// @dev set bundle fee to provided value
     /// may only be called by registered and unlocked pool components

package/contracts/pool/IPoolService.sol

@@ -17,7 +17,7 @@ import {UFixed} from "../type/UFixed.sol";
 
 interface IPoolService is IService {
 
-    event LogPoolServiceMaxCapitalAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
+    event LogPoolServiceMaxBalanceAmountUpdated(NftId poolNftId, Amount previousMaxCapitalAmount, Amount currentMaxCapitalAmount);
     event LogPoolServiceBundleOwnerRoleSet(NftId poolNftId, RoleId bundleOwnerRole);
 
     event LogPoolServiceBundleCreated(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
@@ -29,7 +29,7 @@ interface IPoolService is IService {
     error ErrorPoolServiceBundleOwnerRoleAlreadySet(NftId poolNftId);
     error ErrorPoolServiceInvalidTransferAmount(Amount expectedAmount, Amount actualAmount);
     error ErrorPoolServiceBundlePoolMismatch(NftId bundleNftId, NftId poolNftId);
-    error ErrorPoolServiceMaxCapitalAmountExceeded(NftId poolNftId, Amount maxCapitalAmount, Amount capitalAmount, Amount amountToBeAdded);
+    error ErrorPoolServiceMaxBalanceAmountExceeded(NftId poolNftId, Amount maxBalanceAmount, Amount currentBalanceAmount, Amount transferAmount);
     error ErrorPoolServiceWalletAllowanceTooSmall(address wallet, address spender, uint256 allowance, uint256 amount);
     error ErrorPoolServiceAmountIsZero();
 
@@ -37,16 +37,8 @@ interface IPoolService is IService {
     /// default implementation returns PUBLIC ROLE
     function setBundleOwnerRole(RoleId bundleOwnerRole) external;
 
-    /// @dev sets the max capital amount for the calling pool
-    function setMaxCapitalAmount(Amount maxCapitalAmount) external;
-
-    /// @dev set pool sepecific fees
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    ) external;
-
+    /// @dev sets the max balance amount for the calling pool
+    function setMaxBalanceAmount(Amount maxBalanceAmount) external;
 
     /// @dev locks required collateral to cover the specified application (and turn it into a policy)
     /// - retention level == 1: the full collateral amount will be locked by the specified bundle
@@ -102,8 +94,7 @@ interface IPoolService is IService {
         bytes calldata filter // optional use case specific criteria that define if a policy may be covered by this bundle
     )
         external 
-        returns(NftId bundleNftId); // the nft id of the newly created bundle
-        // TODO: return netAmount
+        returns(NftId bundleNftId, Amount netStakedAmount); // the nft id of the newly created bundle
 
 
     /// @dev closes the specified bundle

package/contracts/pool/Pool.sol

@@ -114,17 +114,13 @@ abstract contract Pool is
         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,
+            UFixedLib.toUFixed(1) // retentionLevel,
         );
     }
 
@@ -233,7 +229,7 @@ abstract contract Pool is
     /// 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)
+    function _closeBundle(NftId bundleNftId)
         internal
         virtual
     {
@@ -255,13 +251,13 @@ abstract contract Pool is
     }
 
 
-    /// @dev Sets the maximum overall capital amound held by this pool.
+    /// @dev Sets the maximum balance amound held by this pool.
     /// Function may only be called by pool owner.
-    function _setMaxCapitalAmount(Amount maxCapitalAmount)
+    function _setMaxBalanceAmount(Amount maxBalanceAmount)
         internal
         virtual
     {
-        _getPoolStorage()._poolService.setMaxCapitalAmount(maxCapitalAmount);
+        _getPoolStorage()._poolService.setMaxBalanceAmount(maxBalanceAmount);
     }
 
     /// @dev Sets the required role to create/own bundles.
@@ -300,9 +296,9 @@ abstract contract Pool is
         bytes memory filter
     )
         internal
-        returns(NftId bundleNftId)
+        returns(NftId bundleNftId, Amount netStakedAmount)
     {
-        bundleNftId = _getPoolStorage()._poolService.createBundle(
+        (bundleNftId, netStakedAmount) = _getPoolStorage()._poolService.createBundle(
             bundleOwner,
             fee,
             amount,

package/contracts/pool/PoolService.sol

@@ -17,7 +17,7 @@ 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 {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";
@@ -68,24 +68,20 @@ contract PoolService is
         registerInterface(type(IPoolService).interfaceId);
     }
 
-
-    function setMaxCapitalAmount(Amount maxCapitalAmount)
+    /// @inheritdoc IPoolService
+    function setMaxBalanceAmount(Amount maxBalanceAmount)
         external
         virtual
     {
-        /*
         (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;
-
-        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)
@@ -109,27 +105,6 @@ contract PoolService is
         emit LogPoolServiceBundleOwnerRoleSet(poolNftId, bundleOwnerRole);
     }
 
-
-    function setFees(
-        Fee memory poolFee,
-        Fee memory stakingFee,
-        Fee memory performanceFee
-    )
-        external
-        virtual
-    {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-
-        IComponents.PoolInfo memory poolInfo = instance.getInstanceReader().getPoolInfo(poolNftId);
-        poolInfo.poolFee = poolFee;
-        poolInfo.stakingFee = stakingFee;
-        poolInfo.performanceFee = performanceFee;
-
-        instance.getInstanceStore().updatePool(poolNftId, poolInfo, KEEP_STATE());
-
-        // TODO add logging
-    }
-
     /// @inheritdoc IPoolService
     function createBundle(
         address bundleOwner, // initial bundle owner
@@ -140,26 +115,32 @@ contract PoolService is
     )
         external 
         virtual
-        returns(NftId bundleNftId)
+        returns(NftId bundleNftId, Amount netStakedAmount)
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        InstanceReader instanceReader = instance.getInstanceReader();
 
-        (
-            Amount stakingFeeAmount,
-            Amount stakingNetAmount
-        ) = FeeLib.calculateFee(
-            _getStakingFee(instanceReader, poolNftId), 
+        {
+            InstanceReader instanceReader = instance.getInstanceReader();
+            IComponents.PoolInfo memory poolInfo = instanceReader.getPoolInfo(poolNftId);
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + stakingAmount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, stakingAmount);
+            }
+        }
+
+
+        Amount stakingFeeAmount;
+        (stakingFeeAmount, netStakedAmount) = FeeLib.calculateFee(
+            _getStakingFee(instance.getInstanceReader(), poolNftId), 
             stakingAmount);
 
-        // TODO: staking amount must be be > maxCapitalAmount
 
         bundleNftId = _bundleService.create(
             instance,
             poolNftId,
             bundleOwner,
             fee,
-            stakingNetAmount,
+            netStakedAmount,
             lifetime,
             filter);
 
@@ -167,12 +148,12 @@ contract PoolService is
         _componentService.increasePoolBalance(
             instance.getInstanceStore(), 
             poolNftId, 
-            stakingNetAmount, 
+            netStakedAmount, 
             stakingFeeAmount);
 
         // pool bookkeeping and collect tokens from bundle owner
         _collectStakingAmount(
-            instanceReader, 
+            instance.getInstanceReader(), 
             poolNftId, 
             bundleOwner, 
             stakingAmount);
@@ -196,14 +177,40 @@ contract PoolService is
     {
         (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);
+            TokenHandler tokenHandler = poolComponentInfo.tokenHandler;
+            IERC20Metadata token = IERC20Metadata(poolComponentInfo.token);
+
+            // TODO: centralize token handling (issue #471)
+            
+            // check allowance
+            uint256 tokenAllowance = token.allowance(poolComponentInfo.wallet, address(tokenHandler));
+            if (tokenAllowance < (unstakedAmount.toInt() +  feeAmount.toInt())) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(
+                    poolComponentInfo.wallet, 
+                    address(tokenHandler), 
+                    tokenAllowance, 
+                    unstakedAmount.toInt() + feeAmount.toInt());
+            }
+
+            // transfer amount to bundle owner
+            address bundleOwner = getRegistry().ownerOf(bundleNftId);
+            tokenHandler.transfer(poolComponentInfo.wallet, bundleOwner, unstakedAmount + feeAmount);
+        }
     }
 
     /// @inheritdoc IPoolService
@@ -222,15 +229,18 @@ contract PoolService is
             revert ErrorPoolServiceBundlePoolMismatch(bundleNftId, poolNftId);
         }
 
-        Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
-        if (amount + currentPoolBalance > poolInfo.maxCapitalAmount) {
-            revert ErrorPoolServiceMaxCapitalAmountExceeded(poolNftId, poolInfo.maxCapitalAmount, currentPoolBalance, amount);
+        {
+            Amount currentPoolBalance = instanceReader.getBalanceAmount(poolNftId);
+            if (currentPoolBalance + amount > poolInfo.maxBalanceAmount) {
+                revert ErrorPoolServiceMaxBalanceAmountExceeded(poolNftId, poolInfo.maxBalanceAmount, currentPoolBalance, amount);
+            }
         }
 
         // calculate fees
+        Amount feeAmount;
         (
-            Amount feeAmount,
-            Amount netAmount
+            feeAmount,
+            netAmount
         ) = FeeLib.calculateFee(
             _getStakingFee(instanceReader, poolNftId), 
             amount);
@@ -246,13 +256,12 @@ contract PoolService is
 
         // collect tokens from bundle owner
         address bundleOwner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
         _collectStakingAmount(
             instanceReader, 
             poolNftId, 
             bundleOwner, 
             amount);
-
-        emit LogPoolServiceBundleStaked(instance.getNftId(), poolNftId, bundleNftId, amount, netAmount);
     }
 
     /// @inheritdoc IPoolService
@@ -304,24 +313,12 @@ contract PoolService is
 
         // transfer amount to bundle owner
         address owner = getRegistry().ownerOf(bundleNftId);
+        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
         // TODO: centralize token handling (issue #471)
         poolComponentInfo.tokenHandler.transfer(poolWallet, owner, unstakedAmount);
-        
-        emit LogPoolServiceBundleUnstaked(instance.getNftId(), poolNftId, bundleNftId, unstakedAmount);
-
         return unstakedAmount;
     }
 
-    function _getPerformanceFee(InstanceReader instanceReader, NftId poolNftId)
-        internal
-        virtual
-        view
-        returns (Fee memory performanceFee)
-    {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).performanceFee;
-    }
-
     function processSale(
         NftId bundleNftId, 
         IPolicy.Premium memory premium 

package/contracts/product/ApplicationService.sol

@@ -128,6 +128,7 @@ contract ApplicationService is
         address applicationOwner,
         RiskId riskId,
         Amount sumInsuredAmount,
+        Amount premiumAmount,
         Seconds lifetime,
         NftId bundleNftId,
         ReferralId referralId,
@@ -152,13 +153,45 @@ contract ApplicationService is
         applicationNftId = _registerApplication(productNftId, applicationOwner);
 
         // create policy info for application
-        IPolicy.PolicyInfo memory applicationInfo = IPolicy.PolicyInfo({
+        IPolicy.PolicyInfo memory applicationInfo = _createApplicationInfo(
+            productNftId,
+            riskId,
+            sumInsuredAmount,
+            premiumAmount,
+            lifetime,
+            bundleNftId,
+            referralId,
+            applicationData);
+
+        // register application with instance
+        instance.getInstanceStore().createApplication(
+            applicationNftId, 
+            applicationInfo);
+
+        // TODO: add logging
+    }
+
+    function _createApplicationInfo(
+        NftId productNftId,
+        RiskId riskId,
+        Amount sumInsuredAmount,
+        Amount premiumAmount,
+        Seconds lifetime,
+        NftId bundleNftId,
+        ReferralId referralId,
+        bytes memory applicationData
+    )
+        internal
+        virtual
+        returns (IPolicy.PolicyInfo memory applicationInfo)
+    {
+        return IPolicy.PolicyInfo({
             productNftId:       productNftId,
             bundleNftId:        bundleNftId,
             referralId:         referralId,
             riskId:             riskId,
             sumInsuredAmount:   sumInsuredAmount,
-            premiumAmount:      AmountLib.zero(),
+            premiumAmount:      premiumAmount,
             premiumPaidAmount:  AmountLib.zero(),
             lifetime:           lifetime,
             applicationData:    applicationData,
@@ -171,21 +204,8 @@ contract ApplicationService is
             expiredAt:          zeroTimestamp(),
             closedAt:           zeroTimestamp()
         });
-
-        // TODO consider to provide this amount externally
-        // actual calculation is done 2nd time anyway for premium collection
-        // calculate premium amount
-        applicationInfo.premiumAmount = _calculatePremiumAmount(applicationInfo);
-
-        // register application with instance
-        instance.getInstanceStore().createApplication(
-            applicationNftId, 
-            applicationInfo);
-
-        // TODO: add logging
     }
 
-
     function renew(
         NftId policyNftId, // policy to be renewd (renewal inherits policy attributes)
         NftId bundleNftId // will likely need a newer bundle for underwriting
@@ -194,7 +214,7 @@ contract ApplicationService is
         virtual override
         returns (NftId applicationNftId)
     {
-
+        // TODO implement
     }
 
 
@@ -210,7 +230,7 @@ contract ApplicationService is
         external
         virtual override
     {
-
+        // TODO implement
     }
 
     function revoke(NftId applicationNftId)