@etherisc/gif-next 0.0.2-bcecc4c-647 → 0.0.2-bd8fe7c-423

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
@@ -241,12 +252,14 @@ contract BundleService is
     ) 
         external 
         virtual
-        restricted()
+        // 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);
         }
 
@@ -265,7 +278,8 @@ contract BundleService is
     ) 
         external 
         virtual
-        restricted()
+        // TODO: restricted() (once #462 is done)
+        returns (Amount unstakedAmount)
     {
         InstanceStore instanceStore = instance.getInstanceStore();
         (
@@ -274,29 +288,38 @@ contract BundleService is
             Amount feeAmount
         ) = instanceStore.getAmounts(bundleNftId);
 
+        Amount unstakedAmount = amount;
         Amount availableAmount = balanceAmount - (lockedAmount + feeAmount);
+
+        // if amount is max, then unstake all available 
+        if (amount.gte(AmountLib.max())) {
+            unstakedAmount = availableAmount;
+        }
         
-        if (availableAmount < amount) {
-            revert ErrorBundleServiceStakeAmountExceedsLimit(amount, availableAmount);
+        // ensure unstaked amount does not exceed available amount
+        if (unstakedAmount > availableAmount) {
+            revert ErrorBundleServiceUnstakeAmountExceedsLimit(amount, availableAmount);
         }
 
         _componentService.decreaseBundleBalance(
             instanceStore, 
             bundleNftId, 
-            amount, 
+            unstakedAmount, 
             AmountLib.zero());
+
+        return unstakedAmount;
     }
 
     /// @inheritdoc IBundleService
     function extend(NftId bundleNftId, Seconds lifetimeExtension) 
         external 
         virtual
-        restricted
+        // TODO: restricted() (once #462 is done)
         returns (Timestamp extendedExpiredAt) 
     {
         (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) {
@@ -308,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());
 
@@ -395,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,12 +26,13 @@ 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 ErrorBundleServiceStakeAmountExceedsLimit(Amount amount, Amount limit);
+    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,13 +52,17 @@ 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;
 
     /// @dev decrease bundle stakes by the specified amount
     /// may only be called by the pool service
-    function unstake(IInstance instance, NftId bundleNftId, Amount amount) external;
+    /// @param instance the instance relevant for the bundle
+    /// @param bundleNftId the bundle nft id
+    /// @param amount the amount to unstake (set to AmountLib.max() to unstake all available stakes)
+    /// @return unstakedAmount the effective unstaked amount
+    function unstake(IInstance instance, NftId bundleNftId, Amount amount) external returns (Amount unstakedAmount);
 
     /// @dev extend the lifetime of the bundle by the specified time in seconds
     function extend(NftId bundleNftId, Seconds lifetimeExtension) external returns (Timestamp extendedExpiredAt);
@@ -76,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,33 +17,28 @@ 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);
     event LogPoolServiceBundleClosed(NftId instanceNftId, NftId poolNftId, NftId bundleNftId);
 
     event LogPoolServiceBundleStaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount, Amount netAmount);
+    event LogPoolServiceBundleUnstaked(NftId instanceNftId, NftId poolNftId, NftId bundleNftId, Amount amount);
 
     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();
 
     /// @dev defines the required role for bundle owners for the calling pool
     /// 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
@@ -99,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

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
 import {IBundle} from "../instance/module/IBundle.sol";
 import {IBundleService} from "./IBundleService.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
@@ -15,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";
@@ -66,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)
@@ -107,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
@@ -138,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);
 
@@ -165,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);
@@ -184,8 +167,8 @@ contract PoolService is
         view
         returns (Fee memory stakingFee)
     {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).stakingFee;
+        NftId productNftId = instanceReader.getComponentInfo(poolNftId).productNftId;
+        return instanceReader.getProductInfo(productNftId).stakingFee;
     }
 
     function closeBundle(NftId bundleNftId)
@@ -194,21 +177,47 @@ 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
     function stake(NftId bundleNftId, Amount amount) 
         external 
         virtual
-        restricted()
+        // TODO: restricted() (once #462 is done)
         returns(Amount netAmount) 
     {
         (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
@@ -220,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);
@@ -244,69 +256,67 @@ 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
     function unstake(NftId bundleNftId, Amount amount) 
         external 
         virtual
-        restricted()
+        // 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);
         }
 
+        if (amount.eqz()) {
+            revert ErrorPoolServiceAmountIsZero();
+        }
+
         // call bundle service for bookkeeping and additional checks
-        _bundleService.unstake(instance, bundleNftId, amount);
+        Amount unstakedAmount = _bundleService.unstake(instance, bundleNftId, amount);
 
-        // TODO: no performance fees right now -> separate new ticket
-        // FIXME: performance fee is only calculated on the earnings
-        (
-            Amount performanceFeeAmount,
-            Amount netAmount
-        ) = FeeLib.calculateFee(
-            _getPerformanceFee(instanceReader, poolNftId), 
-            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, 
-            amount, 
+            unstakedAmount, 
             AmountLib.zero());
 
-        _componentService.increasePoolBalance(
-            instanceStore, 
-            poolNftId, 
-            AmountLib.zero(), 
-            performanceFeeAmount);
-
-        // TODO: transfer net amount to bundle owner (allowance)
+        IComponents.ComponentInfo memory poolComponentInfo = instanceReader.getComponentInfo(poolNftId);
+        address poolWallet = poolComponentInfo.wallet;
 
-        // TODO: log event
-    }
+        // check allowance
+        {
+            IERC20Metadata token = IERC20Metadata(poolComponentInfo.token);
+            uint256 tokenAllowance = token.allowance(poolWallet, address(poolComponentInfo.tokenHandler));
+            if (tokenAllowance < unstakedAmount.toInt()) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(poolWallet, address(poolComponentInfo.tokenHandler), tokenAllowance, amount.toInt());
+            }
+        }
 
-    function _getPerformanceFee(InstanceReader instanceReader, NftId poolNftId)
-        internal
-        virtual
-        view
-        returns (Fee memory performanceFee)
-    {
-        NftId productNftId = instanceReader.getPoolInfo(poolNftId).productNftId;
-        return instanceReader.getPoolInfo(productNftId).performanceFee;
+        // 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);
+        return unstakedAmount;
     }
 
     function processSale(
@@ -528,11 +538,18 @@ contract PoolService is
         address poolWallet = componentInfo.wallet;
 
         if(amount.gtz()) {
+            uint256 allowance = IERC20Metadata(componentInfo.token).allowance(bundleOwner, address(tokenHandler));
+            if (allowance < amount.toInt()) {
+                revert ErrorPoolServiceWalletAllowanceTooSmall(bundleOwner, address(tokenHandler), allowance, amount.toInt());
+            }
+
             // TODO: centralize token handling (issue #471)
             tokenHandler.transfer(
                 bundleOwner,
                 poolWallet,
                 amount);
+        } else {
+            revert ErrorPoolServiceAmountIsZero();
         }
     }