@etherisc/gif-next 0.0.2-a2def05-550 → 0.0.2-a307d03-692

package/contracts/shared/ComponentService.sol

@@ -1,42 +1,44 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Amount, AmountLib} from "../type/Amount.sol";
-import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
-import {Fee, FeeLib} from "../type/Fee.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+import {IAccountingService} from "../accounting/IAccountingService.sol";
+import {IComponent} from "../shared/IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
 import {IComponentService} from "./IComponentService.sol";
 import {IInstance} from "../instance/IInstance.sol";
 import {IInstanceLinkedComponent} from "./IInstanceLinkedComponent.sol";
+import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
 import {InstanceReader} from "../instance/InstanceReader.sol";
 import {InstanceStore} from "../instance/InstanceStore.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPoolComponent} from "../pool/IPoolComponent.sol";
 import {IProductComponent} from "../product/IProductComponent.sol";
+import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.sol";
+
+import {Amount, AmountLib} from "../type/Amount.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
+import {Fee, FeeLib} from "../type/Fee.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, REGISTRY, COMPONENT, DISTRIBUTION, INSTANCE, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
-import {RoleId, DISTRIBUTION_OWNER_ROLE, ORACLE_OWNER_ROLE, POOL_OWNER_ROLE, PRODUCT_OWNER_ROLE} from "../type/RoleId.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {ObjectType, ACCOUNTING, REGISTRY, COMPONENT, DISTRIBUTION, INSTANCE, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
+import {Service} from "../shared/Service.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenHandlerDeployerLib} from "../shared/TokenHandlerDeployerLib.sol";
+import {VersionPart} from "../type/Version.sol";
+
 
 contract ComponentService is
-    ComponentVerifyingService,
+    Service,
     IComponentService
 {
-    error ErrorComponentServiceAlreadyRegistered(address component);
-    error ErrorComponentServiceNotComponent(address component);
-    error ErrorComponentServiceInvalidType(address component, ObjectType requiredType, ObjectType componentType);
-    error ErrorComponentServiceSenderNotOwner(address component, address initialOwner, address sender);
-    error ErrorComponentServiceExpectedRoleMissing(NftId instanceNftId, RoleId requiredRole, address sender);
-    error ErrorComponentServiceComponentLocked(address component);
-    error ErrorComponentServiceSenderNotService(address sender);
-    error ErrorComponentServiceComponentTypeInvalid(address component, ObjectType expectedType, ObjectType foundType);
-
     bool private constant INCREASE = true;
     bool private constant DECREASE = false;
 
+    IAccountingService private _accountingService;
     IRegistryService private _registryService;
     IInstanceService private _instanceService;
 
@@ -48,13 +50,14 @@ contract ComponentService is
         virtual override
         initializer()
     {
-        // TODO check this, might no longer be the way, refactor if necessary
-        address registryAddress;
-        address initialOwner;
-        (registryAddress, initialOwner) = abi.decode(data, (address, address));
+        (
+            address authority,
+            address registry
+        ) = abi.decode(data, (address, address));
 
-        _initializeService(registryAddress, address(0), owner);
+        __Service_init(authority, registry, owner);
 
+        _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
 
@@ -63,91 +66,181 @@ contract ComponentService is
 
     //-------- component ----------------------------------------------------//
 
-    function setWallet(address newWallet) external virtual {
-        (NftId componentNftId,, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        IComponents.ComponentInfo memory info = instance.getInstanceReader().getComponentInfo(componentNftId);
-        address currentWallet = info.wallet;
+    /// @inheritdoc IComponentService
+    function registerComponent(address componentAddress)
+        external
+        virtual
+        restricted()
+        returns (NftId componentNftId)
+    {
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
+
+        (
+            IInstanceLinkedComponent component,
+            IRegistry.ObjectInfo memory componentInfo // initial component info
+        ) = _getAndVerifyRegisterableComponent(
+            componentAddress,
+            productNftId);
+        ObjectType componentType = componentInfo.objectType;
 
-        if (newWallet == address(0)) {
-            revert ErrorComponentServiceNewWalletAddressZero();
+        if (componentType == POOL()) {
+            IPoolComponent pool = IPoolComponent(componentAddress);
+            return _registerPool(instance, productNftId, pool, componentInfo);
         }
-
-        if (currentWallet == address(0)) {
-            revert ErrorComponentServiceWalletAddressZero();
+        if (componentType == DISTRIBUTION()) {
+            return _registerDistribution(instance, productNftId, component, componentInfo);
         }
-
-        if (newWallet == currentWallet) {
-            revert ErrorComponentServiceWalletAddressIsSameAsCurrent();
+        if (componentType == ORACLE()) {
+            return _registerOracle(instance, productNftId, component, componentInfo);
         }
 
-        info.wallet = newWallet;
-        instance.getInstanceStore().updateComponent(componentNftId, info, KEEP_STATE());
-        emit LogComponentServiceWalletAddressChanged(componentNftId, currentWallet, newWallet);
+        // fail
+        revert ErrorComponentServiceComponentTypeNotSupported(componentAddress, componentType);
+    }
+
+    /// @inheritdoc IComponentService
+    function approveTokenHandler(
+        IERC20Metadata token,
+        Amount amount
+    )
+        external
+        virtual
+        restricted()
+    {
+        // checks
+        (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
+        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
+            componentNftId).tokenHandler;
+
+        // effects
+        tokenHandler.approve(token, amount);
     }
 
-    // TODO implement
-    function lock() external virtual {}
+    /// @inheritdoc IComponentService
+    function setWallet(address newWallet)
+        external
+        virtual
+        restricted()
+    {
+        // checks
+        (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
+        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
+            componentNftId).tokenHandler;
+
+        // effects
+        tokenHandler.setWallet(newWallet);
+    }
 
-    // TODO implement
-    function unlock() external virtual {}
+    /// @inheritdoc IComponentService
+    function setComponentLocked(address componentAddress, bool locked) 
+        external 
+        virtual
+        restricted()
+    {
+        // TODO inactive component can lock/unlock other components?
+        (, IInstance instance) = _getAndVerifyComponent(COMPONENT(), false);
+        instance.setLockedFromService(componentAddress, locked);
+    }
 
+    /// @inheritdoc IComponentService
     function withdrawFees(Amount amount)
         external
         virtual
+        restricted()
         returns (Amount withdrawnAmount)
     {
-        (NftId componentNftId,, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        IComponents.ComponentInfo memory info = instance.getInstanceReader().getComponentInfo(componentNftId);
-        address componentWallet = info.wallet;
+        // checks
+        (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
+        InstanceReader instanceReader = instance.getInstanceReader();
 
         // determine withdrawn amount
+        Amount maxAvailableAmount = instanceReader.getFeeAmount(componentNftId);
         withdrawnAmount = amount;
-        if (withdrawnAmount.gte(AmountLib.max())) {
-            withdrawnAmount = instance.getInstanceReader().getFeeAmount(componentNftId);
-        } else if (withdrawnAmount.eqz()) {
+
+        // max amount -> withraw all available fees
+        if (amount == AmountLib.max()) {
+            withdrawnAmount = maxAvailableAmount;
+        }
+
+        // check modified withdrawn amount
+        if (withdrawnAmount.eqz()) {
             revert ErrorComponentServiceWithdrawAmountIsZero();
-        } else {
-            Amount withdrawLimit = instance.getInstanceReader().getFeeAmount(componentNftId);
-            if (withdrawnAmount.gt(withdrawLimit)) {
-                revert ErrorComponentServiceWithdrawAmountExceedsLimit(withdrawnAmount, withdrawLimit);
-            }
+        } else if (withdrawnAmount > maxAvailableAmount) {
+            revert ErrorComponentServiceWithdrawAmountExceedsLimit(withdrawnAmount, maxAvailableAmount);
         }
 
+        // effects
         // decrease fee counters by withdrawnAmount
-        _changeTargetBalance(DECREASE, instance.getInstanceStore(), componentNftId, AmountLib.zero(), withdrawnAmount);
+        _accountingService.decreaseComponentFees(
+            instance.getInstanceStore(), 
+            componentNftId, 
+            withdrawnAmount);
         
         // transfer amount to component owner
         address componentOwner = getRegistry().ownerOf(componentNftId);
-        emit LogComponentServiceComponentFeesWithdrawn(componentNftId, componentOwner, address(info.token), withdrawnAmount);
-        info.tokenHandler.distributeTokens(componentWallet, componentOwner, withdrawnAmount);
+        TokenHandler tokenHandler = instanceReader.getTokenHandler(componentNftId);
+        emit LogComponentServiceComponentFeesWithdrawn(
+            componentNftId, 
+            componentOwner, 
+            address(tokenHandler.TOKEN()), 
+            withdrawnAmount);
+
+        // interactions
+        // transfer amount to component owner
+        tokenHandler.pushFeeToken(
+            componentOwner, 
+            withdrawnAmount);
     }
 
 
     //-------- product ------------------------------------------------------//
 
-    function registerProduct()
+    function registerProduct(address productAddress)
         external
         virtual
+        restricted()
+        nonReentrant()
+        returns (NftId productNftId)
     {
-        address contractAddress = msg.sender;
+        // TODO proper instance verification, will be done in next PR
+        //(NftId instanceNftId,, IInstance instance) = _getAndVerifyCallingInstance();
+        NftId instanceNftId = getRegistry().getNftIdForAddress(msg.sender);
+        IInstance instance = IInstance(msg.sender);
 
-        // register/create component setup
         (
-            InstanceReader instanceReader, 
-            InstanceStore instanceStore, 
-            NftId productNftId
-        ) = _register(
-            contractAddress,
-            PRODUCT(),
-            PRODUCT_OWNER_ROLE());
-        
-        // create product info
-        IComponents.ProductInfo memory productInfo = IProductComponent(contractAddress).getInitialProductInfo();
-        instanceStore.createProduct(productNftId, productInfo);
+            ,
+            IRegistry.ObjectInfo memory productInfo // initial product info
+        ) = _getAndVerifyRegisterableComponent(
+            productAddress,
+            instanceNftId);
+
+        if(productInfo.objectType != PRODUCT()) {
+            revert ErrorComponentServiceComponentTypeNotSupported(productAddress, productInfo.objectType);
+        }
+
+        InstanceAdmin instanceAdmin = instance.getInstanceAdmin();
+        InstanceStore instanceStore = instance.getInstanceStore();
 
-        // link distribution and pool to product
-        _linkToProduct(instanceReader, instanceStore, productInfo.distributionNftId, productNftId);
-        _linkToProduct(instanceReader, instanceStore, productInfo.poolNftId, productNftId);
+        // register/create component info
+        IProductComponent product = IProductComponent(productAddress);
+        productNftId = _register(instanceAdmin, instanceStore, product, productInfo);
+
+        // create product in instance instanceStore
+        IComponents.ProductInfo memory initialProductInfo = product.getInitialProductInfo();
+        // force initialization of linked components with empty values to 
+        // ensure no components are linked upon initialization of the product
+        initialProductInfo.poolNftId = NftIdLib.zero();
+        initialProductInfo.distributionNftId = NftIdLib.zero();
+        initialProductInfo.oracleNftId = new NftId[](initialProductInfo.expectedNumberOfOracles);
+
+        // create info
+        instanceStore.createProduct(
+            productNftId, 
+            initialProductInfo);
+
+        instanceStore.createFee(
+            productNftId, 
+            product.getInitialFeeInfo());
     }
 
 
@@ -157,68 +250,66 @@ contract ComponentService is
     )
         external
         virtual
+        restricted()
+        nonReentrant()
     {
-        (NftId productNftId,, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
-        IComponents.ProductInfo memory productInfo = instance.getInstanceReader().getProductInfo(productNftId);
+        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+        IComponents.FeeInfo memory feeInfo = instance.getInstanceReader().getFeeInfo(productNftId);
         bool feesChanged = false;
 
         // update product fee if required
-        if(!FeeLib.eq(productInfo.productFee, productFee)) {
-            _logUpdateFee(productNftId, "ProductFee", productInfo.productFee, productFee);
-            productInfo.productFee = productFee;
+        if(!FeeLib.eq(feeInfo.productFee, productFee)) {
+            _logUpdateFee(productNftId, "ProductFee", feeInfo.productFee, productFee);
+            feeInfo.productFee = productFee;
             feesChanged = true;
         }
 
         // update processing fee if required
-        if(!FeeLib.eq(productInfo.processingFee, processingFee)) {
-            _logUpdateFee(productNftId, "ProcessingFee", productInfo.processingFee, processingFee);
-            productInfo.processingFee = processingFee;
+        if(!FeeLib.eq(feeInfo.processingFee, processingFee)) {
+            _logUpdateFee(productNftId, "ProcessingFee", feeInfo.processingFee, processingFee);
+            feeInfo.processingFee = processingFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceProductFeesUpdated(productNftId);
         }
     }
 
-    function increaseProductFees(
-        InstanceStore instanceStore,
-        NftId productNftId, 
-        Amount feeAmount
-    ) 
-        external 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(INCREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
-    }
-
-
-    function decreaseProductFees(InstanceStore instanceStore, NftId productNftId, Amount feeAmount)
-        external 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(DECREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
-    }
-
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
-    function registerDistribution()
-        external
+    function _registerDistribution(
+        IInstance instance,
+        NftId productNftId,
+        IInstanceLinkedComponent distribution,
+        IRegistry.ObjectInfo memory info
+    )
+        internal
         virtual
+        nonReentrant()
+        returns (NftId distributionNftId)
     {
-        address contractAddress = msg.sender;
+        InstanceReader reader = instance.getInstanceReader();
+        InstanceAdmin instanceAdmin = instance.getInstanceAdmin();
+        InstanceStore instanceStore = instance.getInstanceStore();
 
         // register/create component info
-        _register(
-            contractAddress,
-            DISTRIBUTION(),
-            DISTRIBUTION_OWNER_ROLE());
+        distributionNftId = _register(instanceAdmin, instanceStore, distribution, info);
+
+        // check product is still expecting a distribution registration
+        IComponents.ProductInfo memory productInfo = reader.getProductInfo(productNftId);
+        if (!productInfo.hasDistribution) {
+            revert ErrorProductServiceNoDistributionExpected(productNftId);
+        }
+        if (productInfo.distributionNftId.gtz()) {
+            revert ErrorProductServiceDistributionAlreadyRegistered(productNftId, productInfo.distributionNftId);
+        }
+
+        // set distribution in product info
+        productInfo.distributionNftId = distributionNftId;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
 
@@ -228,133 +319,100 @@ contract ComponentService is
     )
         external
         virtual
+        restricted()
     {
-        (NftId distributionNftId,, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
-        (NftId productNftId, IComponents.ProductInfo memory productInfo) = _getLinkedProductInfo(
+        (NftId distributionNftId, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), distributionNftId);
         bool feesChanged = false;
 
         // update distributino fee if required
-        if(!FeeLib.eq(productInfo.distributionFee, distributionFee)) {
-            _logUpdateFee(productNftId, "DistributionFee", productInfo.distributionFee, distributionFee);
-            productInfo.distributionFee = distributionFee;
+        if(!FeeLib.eq(feeInfo.distributionFee, distributionFee)) {
+            _logUpdateFee(productNftId, "DistributionFee", feeInfo.distributionFee, distributionFee);
+            feeInfo.distributionFee = distributionFee;
             feesChanged = true;
         }
 
         // update min distribution owner fee if required
-        if(!FeeLib.eq(productInfo.minDistributionOwnerFee, minDistributionOwnerFee)) {
-            _logUpdateFee(productNftId, "MinDistributionOwnerFee", productInfo.minDistributionOwnerFee, minDistributionOwnerFee);
-            productInfo.minDistributionOwnerFee = minDistributionOwnerFee;
+        if(!FeeLib.eq(feeInfo.minDistributionOwnerFee, minDistributionOwnerFee)) {
+            _logUpdateFee(productNftId, "MinDistributionOwnerFee", feeInfo.minDistributionOwnerFee, minDistributionOwnerFee);
+            feeInfo.minDistributionOwnerFee = minDistributionOwnerFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceDistributionFeesUpdated(distributionNftId);
         }
     }
 
-    function increaseDistributionBalance(
-        InstanceStore instanceStore, 
-        NftId distributionNftId, 
-        Amount amount,
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(INCREASE, instanceStore, distributionNftId, amount, feeAmount);
-    }
-
-
-    function decreaseDistributionBalance(
-        InstanceStore instanceStore, 
-        NftId distributionNftId, 
-        Amount amount,
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(DECREASE, instanceStore, distributionNftId, amount, feeAmount);
-    }
-
-    //-------- distributor -------------------------------------------------------//
-
-    function increaseDistributorBalance(
-        InstanceStore instanceStore, 
-        NftId distributorNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(INCREASE, instanceStore, distributorNftId, amount, feeAmount);
-    }
+    //-------- oracle -------------------------------------------------------//
 
-    function decreaseDistributorBalance(
-        InstanceStore instanceStore, 
-        NftId distributorNftId, 
-        Amount amount, 
-        Amount feeAmount
+    function _registerOracle(
+        IInstance instance,
+        NftId productNftId,
+        IInstanceLinkedComponent oracle,
+        IRegistry.ObjectInfo memory info
     )
-        external
+        internal
         virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
+        returns (NftId oracleNftId)
     {
-        _changeTargetBalance(DECREASE, instanceStore, distributorNftId, amount, feeAmount);
-    }
+        InstanceReader reader = instance.getInstanceReader();
+        InstanceAdmin instanceAdmin = instance.getInstanceAdmin();
+        InstanceStore instanceStore = instance.getInstanceStore();
 
-    //-------- oracle -------------------------------------------------------//
+        // register/create component info
+        oracleNftId = _register(instanceAdmin, instanceStore, oracle, info);
 
-    function registerOracle()
-        external
-        virtual
-    {
-        address contractAddress = msg.sender;
+        // check product is still expecting an oracle registration
+        IComponents.ProductInfo memory productInfo = reader.getProductInfo(productNftId);
+        if (productInfo.expectedNumberOfOracles == 0) {
+            revert ErrorProductServiceNoOraclesExpected(productNftId);
+        }
+        if (productInfo.numberOfOracles == productInfo.expectedNumberOfOracles) {
+            revert ErrorProductServiceOraclesAlreadyRegistered(productNftId, productInfo.expectedNumberOfOracles);
+        }
 
-        // register/create component setup
-        (
-            , // instance reader
-            InstanceStore instanceStore, 
-            NftId componentNftId
-        ) = _register(
-            contractAddress,
-            ORACLE(),
-            ORACLE_OWNER_ROLE());            
+        // update/add oracle to product info
+        productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
+        productInfo.numberOfOracles++;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
     //-------- pool ---------------------------------------------------------//
 
-    function registerPool()
-        external
+    function _registerPool(
+        IInstance instance,
+        NftId productNftId,
+        IPoolComponent pool,
+        IRegistry.ObjectInfo memory info
+    )
+        internal
         virtual
+        returns (NftId poolNftId)
     {
-        address contractAddress = msg.sender;
+        InstanceReader reader = instance.getInstanceReader();
+        InstanceAdmin instanceAdmin = instance.getInstanceAdmin();
+        InstanceStore instanceStore = instance.getInstanceStore();
 
-        // register/create component setup
-        (
-            , // instance reader
-            InstanceStore instanceStore, 
-            NftId componentNftId
-        ) = _register(
-            contractAddress,
-            POOL(),
-            POOL_OWNER_ROLE());            
+        // register/create component info
+        poolNftId = _register(instanceAdmin, instanceStore, pool, info);
+
+        // check product is still expecting a pool registration
+        IComponents.ProductInfo memory productInfo = reader.getProductInfo(productNftId);
+        if (productInfo.poolNftId.gtz()) {
+            revert ErrorProductServicePoolAlreadyRegistered(productNftId, productInfo.poolNftId);
+        }
 
         // create info
         instanceStore.createPool(
-            componentNftId, 
-            IPoolComponent(
-                contractAddress).getInitialPoolInfo());
+            poolNftId, 
+            pool.getInitialPoolInfo());
+
+        // update pool in product info
+        productInfo.poolNftId = poolNftId;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
 
@@ -364,192 +422,86 @@ contract ComponentService is
         Fee memory performanceFee // pool fee on profits from capital investors
     )
         external
+        restricted()
         virtual
     {
-        (NftId poolNftId,, IInstance instance) = _getAndVerifyActiveComponent(POOL());
-        (NftId productNftId, IComponents.ProductInfo memory productInfo) = _getLinkedProductInfo(
+        (NftId poolNftId, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+
+        (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), poolNftId);
         bool feesChanged = false;
 
         // update pool fee if required
-        if(!FeeLib.eq(productInfo.poolFee, poolFee)) {
-            _logUpdateFee(productNftId, "PoolFee", productInfo.poolFee, poolFee);
-            productInfo.poolFee = poolFee;
+        if(!FeeLib.eq(feeInfo.poolFee, poolFee)) {
+            _logUpdateFee(productNftId, "PoolFee", feeInfo.poolFee, poolFee);
+            feeInfo.poolFee = poolFee;
             feesChanged = true;
         }
 
         // update staking fee if required
-        if(!FeeLib.eq(productInfo.stakingFee, stakingFee)) {
-            _logUpdateFee(productNftId, "StakingFee", productInfo.stakingFee, stakingFee);
-            productInfo.stakingFee = stakingFee;
+        if(!FeeLib.eq(feeInfo.stakingFee, stakingFee)) {
+            _logUpdateFee(productNftId, "StakingFee", feeInfo.stakingFee, stakingFee);
+            feeInfo.stakingFee = stakingFee;
             feesChanged = true;
         }
 
         // update performance fee if required
-        if(!FeeLib.eq(productInfo.performanceFee, performanceFee)) {
-            _logUpdateFee(productNftId, "PerformanceFee", productInfo.performanceFee, performanceFee);
-            productInfo.performanceFee = performanceFee;
+        if(!FeeLib.eq(feeInfo.performanceFee, performanceFee)) {
+            _logUpdateFee(productNftId, "PerformanceFee", feeInfo.performanceFee, performanceFee);
+            feeInfo.performanceFee = performanceFee;
             feesChanged = true;
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateProduct(productNftId, productInfo, KEEP_STATE());
+            instance.getInstanceStore().updateFee(productNftId, feeInfo);
             emit LogComponentServicePoolFeesUpdated(poolNftId);
         }
     }
 
-    function increasePoolBalance(
-        InstanceStore instanceStore, 
-        NftId poolNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        public 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(INCREASE, instanceStore, poolNftId, amount, feeAmount);
-    }
-
-    function decreasePoolBalance(
-        InstanceStore instanceStore, 
-        NftId poolNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        public 
-        virtual 
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(DECREASE, instanceStore, poolNftId, amount, feeAmount);
-    }
-
-    //-------- bundle -------------------------------------------------------//
-
-    function increaseBundleBalance(
-        InstanceStore instanceStore, 
-        NftId bundleNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(INCREASE, instanceStore, bundleNftId, amount, feeAmount);
-    }
-
-    function decreaseBundleBalance(
-        InstanceStore instanceStore, 
-        NftId bundleNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        external
-        virtual
-        // TODO re-enable once role granting is stable and fixed
-        // restricted()
-    {
-        _changeTargetBalance(DECREASE, instanceStore, bundleNftId, amount, feeAmount);
-    }
-
-
-    //-------- internal functions ------------------------------------------//
-
-    function _changeTargetBalance(
-        bool increase,
-        InstanceStore instanceStore, 
-        NftId targetNftId, 
-        Amount amount, 
-        Amount feeAmount
-    )
-        internal
-        virtual
-    {
-        Amount totalAmount = amount + feeAmount;
-
-        if(increase) {
-            if(totalAmount.gtz()) { instanceStore.increaseBalance(targetNftId, totalAmount); }
-            if(feeAmount.gtz()) { instanceStore.increaseFees(targetNftId, feeAmount); }
-        } else {
-            if(totalAmount.gtz()) { instanceStore.decreaseBalance(targetNftId, totalAmount); }
-            if(feeAmount.gtz()) { instanceStore.decreaseFees(targetNftId, feeAmount); }
-        }
-    }
-
-    /// @dev registers the component represented by the provided address
+    /// @dev Registers the component represented by the provided address.
     function _register(
-        address componentAddress, // address of component to register
-        ObjectType requiredType, // required type for component for registration
-        RoleId requiredRole // role required for comonent owner for registration
+        InstanceAdmin instanceAdmin,
+        InstanceStore instanceStore,
+        IInstanceLinkedComponent component,
+        IRegistry.ObjectInfo memory info
     )
         internal
         virtual
-        returns (
-            InstanceReader instanceReader, 
-            InstanceStore instanceStore, 
-            NftId componentNftId
-        )
+        returns (NftId componentNftId)
     {
-        (
-            IInstance instance,
-            IInstanceLinkedComponent component,
-            address owner
-        ) = _getAndVerifyRegisterableComponent(
-            componentAddress,
-            requiredType,
-            requiredRole);
-
         // register component with registry
-        componentNftId = _registryService.registerComponent(
-            component, 
-            requiredType, 
-            owner).nftId;
-
-        component.linkToRegisteredNftId();
-
-        // save amended component info with instance
-        instanceReader = instance.getInstanceReader();
-        instanceStore = instance.getInstanceStore();
+        componentNftId =
+            info.objectType == PRODUCT() ?
+            _registryService.registerProduct(component, info.initialOwner).nftId :
+            _registryService.registerProductLinkedComponent(component, info.objectType, info.initialOwner).nftId;
 
+        // deploy and wire token handler
+        // TODO deploy token handler in instance contract ?!
         IComponents.ComponentInfo memory componentInfo = component.getInitialComponentInfo();
+        IERC20Metadata token = componentInfo.token;
         componentInfo.tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
-            address(componentInfo.token), 
-            address(instance.getInstanceAdmin().authority()));
-
+            address(getRegistry()),
+            address(component), // initially, component is its own wallet
+            address(token), 
+            address(instanceAdmin.authority()));
+        
+        // register component with instance
         instanceStore.createComponent(
-            component.getNftId(), 
+            componentNftId, 
             componentInfo);
 
-        // setup initial component authorization
-        _instanceService.initializeAuthorization(
-            instance.getNftId(),
-            component);
-
-        // TODO add logging
-    }
+        // link component contract to nft id
+        component.linkToRegisteredNftId();
 
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(component);
 
-    /// @dev link the component info corresponding to the componentNftId to the provided productNftId
-    function _linkToProduct(
-        InstanceReader instanceReader, 
-        InstanceStore instanceStore,
-        NftId componentNftId,
-        NftId productNftId
-    )
-        internal
-    {
-        // only link components that are registered
-        if(componentNftId.eqz()) {
-            return;
-        }
-    
-        IComponents.ComponentInfo memory componentInfo = instanceReader.getComponentInfo(componentNftId);
-        componentInfo.productNftId = productNftId;
-        instanceStore.updateComponent(componentNftId, componentInfo, KEEP_STATE());
+        emit LogComponentServiceRegistered(
+            componentNftId, 
+            info.objectType, 
+            address(component), 
+            address(token), 
+            info.initialOwner);
     }
 
 
@@ -568,13 +520,7 @@ contract ComponentService is
     }
 
 
-    function _createSelectors(bytes4 selector) internal pure returns (bytes4[] memory selectors) {
-        selectors = new bytes4[](1);
-        selectors[0] = selector;
-    }
-
-
-    function _getLinkedProductInfo(
+    function _getLinkedFeeInfo(
         InstanceReader instanceReader, 
         NftId componentNftId
     )
@@ -582,57 +528,94 @@ contract ComponentService is
         view 
         returns(
             NftId productNftId, 
-            IComponents.ProductInfo memory info
+            IComponents.FeeInfo memory info
         )
     {
-        productNftId = instanceReader.getComponentInfo(componentNftId).productNftId;
-        info = instanceReader.getProductInfo(productNftId);
+        productNftId = getRegistry().getParentNftId(componentNftId);
+        info = instanceReader.getFeeInfo(productNftId);
     }
 
-
-    /// @dev based on the provided component address required type and role returns the component and related instance contract
-    /// the function reverts iff:
-    /// - the component has already been registered
+    /// @dev Based on the provided component address required type the component 
+    /// and related instance contract this function reverts iff:
     /// - the component contract does not support IInstanceLinkedComponent
-    /// - the component type does not match with the required type
-    /// - the initial component owner misses the required role (with the instance access manager)
+    /// - the component parent does not match with the required parent
+    /// - the component version does not match with the service release
+    /// - the component has already been registered
     function _getAndVerifyRegisterableComponent(
         address componentAddress,
-        ObjectType requiredType,
-        RoleId requiredRole
+        NftId requiredParent
     )
         internal
         view
         returns (
-            IInstance instance,
             IInstanceLinkedComponent component,
-            address owner
+            IRegistry.ObjectInfo memory info
         )
     {
-        // check this is a component
+        // check component interface
+        if (!ContractLib.supportsInterface(componentAddress, type(IInstanceLinkedComponent).interfaceId)) {
+            revert ErrorComponentServiceNotInstanceLinkedComponent(componentAddress);
+        }
+
         component = IInstanceLinkedComponent(componentAddress);
-        if(!component.supportsInterface(type(IInstanceLinkedComponent).interfaceId)) {
-            revert ErrorComponentServiceNotComponent(componentAddress);
+        info = component.getInitialInfo();
+
+        // check component parent
+        if(info.parentNftId != requiredParent) {
+            revert ErrorComponentServiceComponentParentInvalid(componentAddress, requiredParent, info.parentNftId);
         }
 
-        // check component is of required type
-        IRegistry.ObjectInfo memory info = component.getInitialInfo();
-        if(info.objectType != requiredType) {
-            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, info.objectType);
+        // check component release
+        // TODO check version with registry
+        //if(info.version != getRelease()) {
+        if(component.getRelease() != getRelease()) {
+            revert ErrorComponentServiceComponentReleaseMismatch(componentAddress, getRelease(), component.getRelease());
         }
 
         // check component has not already been registered
         if (getRegistry().getNftIdForAddress(componentAddress).gtz()) {
-            revert ErrorComponentServiceAlreadyRegistered(componentAddress);
+            revert ErrorComponentServiceComponentAlreadyRegistered(componentAddress);
         }
+    }
 
-        // check instance has assigned required role to inital owner
-        instance = _getInstance(info.parentNftId);
-        owner = info.initialOwner;
+    function _getAndVerifyActiveComponent(ObjectType expectedType) 
+        internal 
+        view 
+        returns (
+            NftId componentNftId,
+            IInstance instance
+        )
+    {
+        return _getAndVerifyComponent(expectedType, true); // only active
+    }
 
-        if(!instance.getInstanceAdmin().hasRole(owner, requiredRole)) {
-            revert ErrorComponentServiceExpectedRoleMissing(info.parentNftId, requiredRole, owner);
+    function _getAndVerifyComponent(ObjectType expectedType, bool isActive) 
+        internal 
+        view 
+        returns (
+            NftId componentNftId,
+            IInstance instance
+        )
+    {
+        IRegistry.ObjectInfo memory info;
+        address instanceAddress;
+
+        if (expectedType != COMPONENT()) {
+            (info, instanceAddress) = ContractLib.getAndVerifyComponent(
+                getRegistry(),
+                msg.sender, // caller
+                expectedType,
+                isActive); 
+        } else {
+            (info, instanceAddress) = ContractLib.getAndVerifyAnyComponent(
+                getRegistry(),
+                msg.sender,
+                isActive); 
         }
+
+        // get component nft id and instance
+        componentNftId = info.nftId;
+        instance = IInstance(instanceAddress);
     }
 
     function _getDomain() internal pure virtual override returns(ObjectType) {