@etherisc/gif-next 0.0.2-952752e-374 → 0.0.2-957bd35-589

package/contracts/shared/ComponentService.sol

@@ -4,7 +4,6 @@ pragma solidity ^0.8.20;
 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";
@@ -12,23 +11,25 @@ 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 {IStaking} from "../staking/IStaking.sol";
+import {IStakingService} from "../staking/IStakingService.sol";
 
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
 import {Amount, AmountLib} from "../type/Amount.sol";
+import {ChainIdLib} from "../type/ChainId.sol";
 import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.sol";
 import {KEEP_STATE} from "../type/StateId.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, ACCOUNTING, REGISTRY, COMPONENT, DISTRIBUTION, INSTANCE, ORACLE, POOL, PRODUCT} from "../type/ObjectType.sol";
+import {ObjectType, ACCOUNTING, REGISTRY, COMPONENT, DISTRIBUTION, INSTANCE, ORACLE, POOL, PRODUCT, STAKING} from "../type/ObjectType.sol";
+import {ProductStore} from "../instance/ProductStore.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
@@ -40,32 +41,7 @@ contract ComponentService is
 
     IAccountingService private _accountingService;
     IRegistryService private _registryService;
-    IInstanceService private _instanceService;
-
-    modifier onlyComponent(address component) {
-        _checkSupportsInterface(component);
-        _;
-    }
-
-    modifier onlyInstance() {        
-        NftId instanceNftId = getRegistry().getNftIdForAddress(msg.sender);
-        if (instanceNftId.eqz()) {
-            revert ErrorComponentServiceNotRegistered(msg.sender);
-        }
-
-        ObjectType objectType = getRegistry().getObjectInfo(instanceNftId).objectType;
-        if (objectType != INSTANCE()) {
-            revert ErrorComponentServiceNotInstance(msg.sender, objectType);
-        }
-
-        VersionPart instanceVersion = IInstance(msg.sender).getRelease();
-        if (instanceVersion != getVersion().toMajorPart()) {
-            revert ErrorComponentServiceInstanceVersionMismatch(msg.sender, instanceVersion);
-        }
-
-        _;
-    }
-
+    IStaking private _staking;
 
     function _initialize(
         address owner, 
@@ -84,185 +60,212 @@ contract ComponentService is
 
         _accountingService = IAccountingService(_getServiceAddress(ACCOUNTING()));
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
-        _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
+        _staking = IStakingService(_getServiceAddress(STAKING())).getStaking();
 
         _registerInterface(type(IComponentService).interfaceId);
     }
 
     //-------- component ----------------------------------------------------//
 
-    function registerComponent(address component)
+    /// @inheritdoc IComponentService
+    function registerComponent(address componentAddress)
         external
         virtual
-        onlyComponent(component)
+        restricted()
         returns (NftId componentNftId)
     {
-        // type specific registration
-        ObjectType componentType = IInstanceLinkedComponent(component).getInitialInfo().objectType;
-        if (componentType == POOL()) {
-            return _registerPool(component);
-        }
-        if (componentType == DISTRIBUTION()) {
-            return _registerDistribution(component);
-        }
-        if (componentType == ORACLE()) {
-            return _registerOracle(component);
+        // checks
+        // check sender is registered product
+        IRegistry registry = getRegistry();
+        if (!registry.isObjectType(msg.sender, PRODUCT())) {
+            revert ErrorComponentServiceCallerNotProduct(msg.sender);
         }
 
-        // fail
-        revert ErrorComponentServiceTypeNotSupported(component, componentType);
-    }
+        // check provided address is product contract
+        if (!_isInstanceLinkedComponent(componentAddress)) {
+            revert ErrorComponentServiceNotComponent(componentAddress);
+        }
 
-    function approveTokenHandler(
-        IERC20Metadata token,
-        Amount amount
-    )
-        external
-        virtual
-    {
-        // checks
-        (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
-            componentNftId).tokenHandler;
+        NftId productNftId = registry.getNftIdForAddress(msg.sender);
+        IInstance instance = IInstance(
+            registry.getObjectAddress(
+                registry.getParentNftId(productNftId)));
 
-        // effects
-        tokenHandler.approve(token, amount);
+        componentNftId = _verifyAndRegister(
+            instance, 
+            componentAddress, 
+            productNftId, // product is parent of component to be registered
+            address(0)); // token will be inhereited from product
     }
 
 
-    function approveStakingTokenHandler(
+    /// @inheritdoc IComponentService
+    function approveTokenHandler(
         IERC20Metadata token,
         Amount amount
     )
         external
         virtual
+        restricted()
     {
         // checks
-        ContractLib.getAndVerifyStaking(
-            getRegistry(),
-            msg.sender); // only active
+        (NftId componentNftId, IInstance instance) = _getAndVerifyComponent(COMPONENT(), true);
+        TokenHandler tokenHandler = instance.getInstanceReader().getTokenHandler(
+            componentNftId);
 
         // effects
-        TokenHandler tokenHandler = IComponent(msg.sender).getTokenHandler();
         tokenHandler.approve(token, amount);
     }
 
 
+    /// @inheritdoc IComponentService
     function setWallet(address newWallet)
         external
         virtual
+        restricted()
     {
         // checks
-        (NftId componentNftId, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
-            componentNftId).tokenHandler;
+        (NftId componentNftId, IInstance instance) = _getAndVerifyComponent(COMPONENT(), true);
+        TokenHandler tokenHandler = instance.getInstanceReader().getTokenHandler(
+            componentNftId);
 
         // effects
         tokenHandler.setWallet(newWallet);
     }
 
     /// @inheritdoc IComponentService
-    function setLockedFromInstance(address componentAddress, bool locked) 
+    function setLocked(bool locked) 
         external 
         virtual
-        onlyInstance()
-    {
-        address instanceAddress = msg.sender;
-        // NftId instanceNftId = getRegistry().getNftIdForAddress(msg.sender);
-        IInstance instance = IInstance(instanceAddress);
-        _setLocked(instance.getInstanceAdmin(), componentAddress, locked);
-    }
-
-    /// @inheritdoc IComponentService
-    function setLockedFromComponent(address componentAddress, bool locked) 
-        external
-        virtual
-        onlyComponent(msg.sender)
+        restricted()
     {
         (, IInstance instance) = _getAndVerifyComponent(COMPONENT(), false);
-        _setLocked(instance.getInstanceAdmin(), componentAddress, locked);
+
+        address component = msg.sender;
+        instance.getInstanceAdmin().setContractLocked(
+            component, 
+            locked);
+        emit LogComponentServiceComponentLocked(component, 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.tokenHandler.getWallet();
+        // checks
+        (NftId componentNftId, IInstance instance) = _getAndVerifyComponent(COMPONENT(), true);
+        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
-        _accountingService.decreaseComponentFees(instance.getInstanceStore(), componentNftId, 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(address productAddress)
+    /// @inheritdoc IComponentService
+    function registerProduct(address productAddress, address token)
         external
         virtual
+        restricted()
         nonReentrant()
-        onlyComponent(productAddress)
         returns (NftId productNftId)
     {
-        // register/create component setup
-        InstanceAdmin instanceAdmin;
-        InstanceStore instanceStore;
-        (, instanceAdmin, instanceStore,, productNftId) = _register(
-            productAddress,
-            PRODUCT());
-
-        // get product
-        IProductComponent product = IProductComponent(productAddress);
-        
-        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);
+        // checks
+        // check sender is registered instance
+        IRegistry registry = getRegistry();
+        if (!registry.isObjectType(msg.sender, INSTANCE())) {
+            revert ErrorComponentServiceCallerNotInstance(msg.sender);
+        }
 
-        // create info
-        instanceStore.createProduct(
-            productNftId, 
-            initialProductInfo);
-        instanceStore.createFee(
-            productNftId, 
-            product.getInitialFeeInfo());
+        // check provided address is product contract
+        if (!_isProduct(productAddress)) {
+            revert ErrorComponentServiceNotProduct(productAddress);
+        }
 
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(product);
+        IInstance instance = IInstance(msg.sender);
+        NftId instanceNftId = registry.getNftIdForAddress(msg.sender);
+        productNftId = _verifyAndRegister(
+            instance, 
+            productAddress, 
+            instanceNftId, // instance is parent of product to be registered 
+            token);
+
+        // add product specific token for product to staking
+        _staking.addTargetToken(
+            instanceNftId, 
+            token);
+    }
+
+
+    function _isProduct(address target) internal view virtual returns (bool) {
+        if (!_isInstanceLinkedComponent(target)) {
+            return false;
+        }
+
+        return IInstanceLinkedComponent(target).getInitialInfo().objectType == PRODUCT();
+    }
+
+
+    function _isInstanceLinkedComponent(address target) internal view virtual returns (bool) {
+        if (!ContractLib.isContract(target)) {
+            return false;
+        }
+
+        return ContractLib.supportsInterface(target, type(IInstanceLinkedComponent).interfaceId);
     }
 
 
+    /// @inheritdoc IComponentService
     function setProductFees(
         Fee memory productFee, // product fee on net premium
         Fee memory processingFee // product fee on payout amounts        
     )
         external
         virtual
+        restricted()
         nonReentrant()
     {
-        (NftId productNftId, IInstance instance) = _getAndVerifyActiveComponent(PRODUCT());
+        (NftId productNftId, IInstance instance) = _getAndVerifyComponent(PRODUCT(), true);
         IComponents.FeeInfo memory feeInfo = instance.getInstanceReader().getFeeInfo(productNftId);
         bool feesChanged = false;
 
@@ -281,31 +284,53 @@ contract ComponentService is
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateFee(productNftId, feeInfo);
+            instance.getProductStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceProductFeesUpdated(productNftId);
         }
     }
 
+
+    function _createProduct(
+        ProductStore productStore,
+        NftId productNftId,
+        address productAddress
+    )
+        internal
+        virtual
+    {
+        // create product in instance instanceStore
+        IProductComponent product = IProductComponent(productAddress);
+        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
+        productStore.createProduct(
+            productNftId, 
+            initialProductInfo);
+
+        productStore.createFee(
+            productNftId, 
+            product.getInitialFeeInfo());
+    }
+
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
-    function _registerDistribution(address distributioAddress)
+    function _createDistribution(
+        ProductStore productStore,
+        NftId productNftId,
+        NftId distributionNftId,
+        IComponents.ProductInfo memory productInfo
+    )
         internal
         virtual
         nonReentrant()
-        returns (NftId distributionNftId)
     {
-        // register/create component info
-        InstanceReader instanceReader;
-        InstanceAdmin instanceAdmin;
-        InstanceStore instanceStore;
-        NftId productNftId;
-        (instanceReader, instanceAdmin, instanceStore, productNftId, distributionNftId) = _register(
-            distributioAddress,
-            DISTRIBUTION());
-
         // check product is still expecting a distribution registration
-        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
         if (!productInfo.hasDistribution) {
             revert ErrorProductServiceNoDistributionExpected(productNftId);
         }
@@ -315,11 +340,7 @@ contract ComponentService is
 
         // set distribution in product info
         productInfo.distributionNftId = distributionNftId;
-        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(
-            IInstanceLinkedComponent(distributioAddress));
+        productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
 
@@ -329,8 +350,9 @@ contract ComponentService is
     )
         external
         virtual
+        restricted()
     {
-        (NftId distributionNftId, IInstance instance) = _getAndVerifyActiveComponent(DISTRIBUTION());
+        (NftId distributionNftId, IInstance instance) = _getAndVerifyComponent(DISTRIBUTION(), true);
         (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), distributionNftId);
         bool feesChanged = false;
@@ -350,30 +372,23 @@ contract ComponentService is
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateFee(productNftId, feeInfo);
+            instance.getProductStore().updateFee(productNftId, feeInfo);
             emit LogComponentServiceDistributionFeesUpdated(distributionNftId);
         }
     }
 
     //-------- oracle -------------------------------------------------------//
 
-    function _registerOracle(address oracleAddress)
+    function _createOracle(
+        ProductStore productStore,
+        NftId productNftId,
+        NftId oracleNftId,
+        IComponents.ProductInfo memory productInfo
+    )
         internal
         virtual
-        returns (NftId oracleNftId)
     {
-        // register/create component setup
-        InstanceReader instanceReader;
-        InstanceAdmin instanceAdmin;
-        InstanceStore instanceStore;
-        NftId productNftId;
-
-        (instanceReader, instanceAdmin, instanceStore, productNftId, oracleNftId) = _register(
-            oracleAddress,
-            ORACLE());
-
         // check product is still expecting an oracle registration
-        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
         if (productInfo.expectedNumberOfOracles == 0) {
             revert ErrorProductServiceNoOraclesExpected(productNftId);
         }
@@ -384,48 +399,37 @@ contract ComponentService is
         // update/add oracle to product info
         productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
         productInfo.numberOfOracles++;
-        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(
-            IInstanceLinkedComponent(oracleAddress));
+        productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
     //-------- pool ---------------------------------------------------------//
 
-    function _registerPool(address poolAddress)
+    function _createPool(
+        InstanceStore instanceStore,
+        ProductStore productStore,
+        NftId productNftId,
+        NftId poolNftId,
+        address componentAddress,
+        IComponents.ProductInfo memory productInfo
+    )
         internal
         virtual
-        returns (NftId poolNftId)
     {
-        // register/create component setup
-        InstanceReader instanceReader;
-        InstanceAdmin instanceAdmin;
-        InstanceStore instanceStore;
-        NftId productNftId;
-
-        (instanceReader, instanceAdmin, instanceStore, productNftId, poolNftId) = _register(
-            poolAddress,
-            POOL());
-
         // check product is still expecting a pool registration
-        IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+        //IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
         if (productInfo.poolNftId.gtz()) {
             revert ErrorProductServicePoolAlreadyRegistered(productNftId, productInfo.poolNftId);
         }
 
         // create info
-        IPoolComponent pool = IPoolComponent(poolAddress);
+        IPoolComponent pool = IPoolComponent(componentAddress);
         instanceStore.createPool(
             poolNftId, 
             pool.getInitialPoolInfo());
 
         // update pool in product info
         productInfo.poolNftId = poolNftId;
-        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
-
-        // authorize
-        instanceAdmin.initializeComponentAuthorization(pool);
+        productStore.updateProduct(productNftId, productInfo, KEEP_STATE());
     }
 
 
@@ -436,8 +440,9 @@ contract ComponentService is
     )
         external
         virtual
+        restricted()
     {
-        (NftId poolNftId, IInstance instance) = _getAndVerifyActiveComponent(POOL());
+        (NftId poolNftId, IInstance instance) = _getAndVerifyComponent(POOL(), true);
 
         (NftId productNftId, IComponents.FeeInfo memory feeInfo) = _getLinkedFeeInfo(
             instance.getInstanceReader(), poolNftId);
@@ -465,64 +470,79 @@ contract ComponentService is
         }
         
         if(feesChanged) {
-            instance.getInstanceStore().updateFee(productNftId, feeInfo);
+            instance.getProductStore().updateFee(productNftId, feeInfo);
             emit LogComponentServicePoolFeesUpdated(poolNftId);
         }
     }
 
+
     /// @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
+    /// The caller must ensure componentAddress is IInstanceLinkedComponent.
+    function _verifyAndRegister(
+        IInstance instance,
+        address componentAddress,
+        NftId parentNftId,
+        address token
     )
         internal
         virtual
-        returns (
-            InstanceReader instanceReader, 
-            InstanceAdmin instanceAdmin, 
-            InstanceStore instanceStore, 
-            NftId parentNftId,
-            NftId componentNftId
-        )
+        returns (NftId componentNftId)
     {
-        NftId instanceNftId;
-        IInstance instance;
-        IInstanceLinkedComponent component;
-        address initialOwner;
-
         (
-            instanceNftId, 
-            instance, 
-            parentNftId, 
-            component, 
-            initialOwner
+            IInstanceLinkedComponent component,
+            IRegistry.ObjectInfo memory objectInfo // initial component info
         ) = _getAndVerifyRegisterableComponent(
-            getRegistry(),
             componentAddress,
-            requiredType);
+            parentNftId);
 
-        // get instance supporting contracts (as function return values)
-        instanceReader = instance.getInstanceReader();
-        instanceAdmin = instance.getInstanceAdmin();
-        instanceStore = instance.getInstanceStore();
+        InstanceStore instanceStore = instance.getInstanceStore();
+        ObjectType componentType = objectInfo.objectType;
 
-        // register with registry
-        if (requiredType == PRODUCT()) {
+        if(componentType == PRODUCT()) {
+            // register product with registry
             componentNftId = _registryService.registerProduct(
-                component, initialOwner).nftId;
+                component, 
+                objectInfo.initialOwner).nftId;
+
+            // create product info in instance store
+            _createProduct(instance.getProductStore(), componentNftId, componentAddress);
         } else {
+            // register non product component with registry
             componentNftId = _registryService.registerProductLinkedComponent(
-                component, requiredType, initialOwner).nftId;
+                component, 
+                objectInfo.objectType, 
+                objectInfo.initialOwner).nftId;
+
+            InstanceReader instanceReader = instance.getInstanceReader();
+
+            // create non product component info in instance store
+            NftId productNftId = parentNftId;
+            IComponents.ProductInfo memory productInfo = instanceReader.getProductInfo(productNftId);
+            if(componentType == POOL()) {
+                _createPool(instanceStore, instance.getProductStore(), productNftId, componentNftId, componentAddress, productInfo);
+            } else if(componentType == DISTRIBUTION()) {
+                _createDistribution(instance.getProductStore(), productNftId, componentNftId, productInfo);
+            } else if(componentType == ORACLE()) {
+                _createOracle(instance.getProductStore(), productNftId, componentNftId, productInfo);
+            } else {
+                revert ErrorComponentServiceComponentTypeNotSupported(componentAddress, componentType);
+            }
+
+            // get product's token
+            token = address(instanceReader.getTokenHandler(productNftId).TOKEN());
         }
 
+        _checkToken(instance, token);
+
+        InstanceAdmin instanceAdmin = instance.getInstanceAdmin();
+        
         // deploy and wire token handler
         IComponents.ComponentInfo memory componentInfo = component.getInitialComponentInfo();
-        IERC20Metadata token = componentInfo.token;
         componentInfo.tokenHandler = TokenHandlerDeployerLib.deployTokenHandler(
             address(getRegistry()),
             address(component), // initially, component is its own wallet
-            address(token), 
-            address(instanceAdmin.authority()));
+            token, 
+            instanceAdmin.authority());
         
         // register component with instance
         instanceStore.createComponent(
@@ -532,7 +552,34 @@ contract ComponentService is
         // link component contract to nft id
         component.linkToRegisteredNftId();
 
-        emit LogComponentServiceRegistered(instanceNftId, componentNftId, requiredType, address(component), address(token), initialOwner);
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(componentAddress, componentType);
+
+        emit LogComponentServiceRegistered(
+            instance.getNftId(),
+            componentNftId, 
+            componentType, 
+            address(component), 
+            token, 
+            objectInfo.initialOwner);
+    }
+
+
+    function _checkToken(IInstance instance, address token) 
+        internal
+        view
+    {
+        if (! instance.isTokenRegistryDisabled()) {
+            // check if provided token is whitelisted and active
+            if (!ContractLib.isActiveToken(
+                getRegistry().getTokenRegistryAddress(), 
+                ChainIdLib.current(), 
+                token, 
+                AccessManagerCloneable(authority()).getRelease())
+            ) {
+                revert ErrorComponentServiceTokenInvalid(token);
+            }
+        }
     }
 
 
@@ -562,102 +609,51 @@ contract ComponentService is
             IComponents.FeeInfo memory info
         )
     {
-        productNftId = getRegistry().getObjectInfo(componentNftId).parentNftId;
+        productNftId = getRegistry().getParentNftId(componentNftId);
         info = instanceReader.getFeeInfo(productNftId);
     }
 
 
     /// @dev Based on the provided component address required type the component 
     /// and related instance contract this function reverts iff:
-    /// - the sender is not registered
-    /// - the component contract does not support IInstanceLinkedComponent
-    /// - the component type does not match with the required type
+    /// - the component parent does not match with the required parent
+    /// - the component release does not match with the service release
     /// - the component has already been registered
     function _getAndVerifyRegisterableComponent(
-        IRegistry registry,
         address componentAddress,
-        ObjectType requiredType
+        NftId requiredParent
     )
         internal
         view
         returns (
-            NftId instanceNftId,
-            IInstance instance,
-            NftId parentNftId,
             IInstanceLinkedComponent component,
-            address initialOwner
+            IRegistry.ObjectInfo memory info
         )
     {
-        // check sender (instance or product) is registered
-        IRegistry.ObjectInfo memory senderInfo = registry.getObjectInfo(msg.sender);
-        if (senderInfo.nftId.eqz()) {
-            revert ErrorComponentServiceSenderNotRegistered(msg.sender);
-        }
-
-        // the sender is the parent of the component to be registered
-        // an instance caller wanting to register a product - or -
-        // a product caller wantint go register a distribution, oracle or pool
-        parentNftId = senderInfo.nftId;
-
-        // check component is of required type
         component = IInstanceLinkedComponent(componentAddress);
-        IRegistry.ObjectInfo memory info = component.getInitialInfo();
-        if(info.objectType != requiredType) {
-            revert ErrorComponentServiceInvalidType(componentAddress, requiredType, info.objectType);
-        }
-
-        // check component has not already been registered
-        if (getRegistry().getNftIdForAddress(componentAddress).gtz()) {
-            revert ErrorComponentServiceAlreadyRegistered(componentAddress);
-        }
+        info = component.getInitialInfo();
 
-        // check release matches
-        address parentAddress = registry.getObjectAddress(parentNftId);
-        if (component.getRelease() != IRegisterable(parentAddress).getRelease()) {
-            revert ErrorComponentServiceReleaseMismatch(componentAddress, component.getRelease(), IRegisterable(parentAddress).getRelease());
+        // check component parent
+        if(info.parentNftId != requiredParent) {
+            revert ErrorComponentServiceComponentParentInvalid(componentAddress, requiredParent, info.parentNftId);
         }
 
-        // check component belongs to same product cluster 
-        // parent of product must be instance, parent of other componet types must be product
-        if (info.parentNftId != senderInfo.nftId) {
-            revert ErrorComponentServiceSenderNotComponentParent(senderInfo.nftId, info.parentNftId);
+        // check component release (must match with service release)
+        if(component.getRelease() != getRelease()) {
+            revert ErrorComponentServiceComponentReleaseMismatch(componentAddress, getRelease(), component.getRelease());
         }
 
-        // verify parent is registered instance
-        if (requiredType == PRODUCT()) {
-            if (senderInfo.objectType != INSTANCE()) {
-                revert ErrorComponentServiceParentNotInstance(senderInfo.nftId, senderInfo.objectType);
-            }
-
-            instanceNftId = senderInfo.nftId;
-        // verify parent is registered product
-        } else {
-            if (senderInfo.objectType != PRODUCT()) {
-                revert ErrorComponentServiceParentNotProduct(senderInfo.nftId, senderInfo.objectType);
-            }
-
-            instanceNftId = senderInfo.parentNftId;
+        // check component has not already been registered
+        if (getRegistry().getNftIdForAddress(componentAddress).gtz()) {
+            revert ErrorComponentServiceComponentAlreadyRegistered(componentAddress);
         }
-
-        // get initial owner and instance
-        initialOwner = info.initialOwner;
-        instance = IInstance(registry.getObjectAddress(instanceNftId));
     }
 
+
     function _setLocked(InstanceAdmin instanceAdmin, address componentAddress, bool locked) internal {
         instanceAdmin.setTargetLocked(componentAddress, locked);
     }
 
-    function _getAndVerifyActiveComponent(ObjectType expectedType) 
-        internal 
-        view 
-        returns (
-            NftId componentNftId,
-            IInstance instance
-        )
-    {
-        return _getAndVerifyComponent(expectedType, true); // only active
-    }
 
     function _getAndVerifyComponent(ObjectType expectedType, bool isActive) 
         internal 
@@ -688,13 +684,8 @@ contract ComponentService is
         instance = IInstance(instanceAddress);
     }
 
+
     function _getDomain() internal pure virtual override returns(ObjectType) {
         return COMPONENT();
     }
-
-    function _checkSupportsInterface(address component) internal view {
-        if (!ContractLib.supportsInterface(component, type(IInstanceLinkedComponent).interfaceId)) {
-            revert ErrorComponentServiceNotInstanceLinkedComponent(component);
-        }
-    }
 }