@etherisc/gif-next 0.0.2-f11de3a-698 → 0.0.2-f12cf4d-104

package/contracts/shared/ComponentService.sol

@@ -5,36 +5,33 @@ import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IER
 
 import {Amount, AmountLib} from "../type/Amount.sol";
 import {ComponentVerifyingService} from "../shared/ComponentVerifyingService.sol";
+import {ContractLib} from "../shared/ContractLib.sol";
 import {Fee, FeeLib} from "../type/Fee.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 {IRegisterable} from "../shared/IRegisterable.sol";
 import {IPoolComponent} from "../pool/IPoolComponent.sol";
 import {IProductComponent} from "../product/IProductComponent.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegistryService} from "../registry/IRegistryService.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 {TokenHandler} from "./TokenHandler.sol";
+import {ObjectType, REGISTRY, BUNDLE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, INSTANCE, ORACLE, POOL, PRODUCT, STAKING} from "../type/ObjectType.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
+import {TokenHandlerDeployerLib} from "../shared/TokenHandlerDeployerLib.sol";
 
 contract ComponentService is
     ComponentVerifyingService,
     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;
@@ -42,6 +39,14 @@ contract ComponentService is
     IRegistryService private _registryService;
     IInstanceService private _instanceService;
 
+    modifier onlyComponent(address component) {
+        if (!ContractLib.supportsInterface(component, type(IInstanceLinkedComponent).interfaceId)) {
+            revert ErrorComponentServiceNotInstanceLinkedComponent(component);
+        }
+        _;
+    }
+
+
     function _initialize(
         address owner, 
         bytes memory data
@@ -50,41 +55,91 @@ 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 registryAddress,
+            address authority
+        ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, address(0), owner);
+        _initializeService(registryAddress, authority, owner);
 
         _registryService = IRegistryService(_getServiceAddress(REGISTRY()));
         _instanceService = IInstanceService(_getServiceAddress(INSTANCE()));
 
-        registerInterface(type(IComponentService).interfaceId);
+        _registerInterface(type(IComponentService).interfaceId);
     }
 
     //-------- component ----------------------------------------------------//
 
-    function setWallet(address newWallet) external virtual {
+    function registerComponent(address component)
+        external
+        virtual
+        onlyComponent(component)
+        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);
+        }
+
+        // fail
+        revert ErrorComponentServiceTypeNotSupported(component, componentType);
+    }
+
+    function approveTokenHandler(
+        IERC20Metadata token,
+        Amount amount
+    )
+        external
+        virtual
+    {
+        // checks
         (NftId componentNftId,, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
-        IComponents.ComponentInfo memory info = instance.getInstanceReader().getComponentInfo(componentNftId);
-        address currentWallet = info.wallet;
+        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
+            componentNftId).tokenHandler;
 
-        if (newWallet == address(0)) {
-            revert ErrorComponentServiceNewWalletAddressZero();
-        }
+        // effects
+        tokenHandler.approve(token, amount);
+    }
 
-        if (currentWallet == address(0)) {
-            revert ErrorComponentServiceWalletAddressZero();
-        }
 
-        if (newWallet == currentWallet) {
-            revert ErrorComponentServiceWalletAddressIsSameAsCurrent();
-        }
+    function approveStakingTokenHandler(
+        IERC20Metadata token,
+        Amount amount
+    )
+        external
+        virtual
+    {
+        // checks
+        NftId stakingNftId = getRegistry().getNftIdForAddress(msg.sender);
+        (IRegistry.ObjectInfo memory objectInfo,) = _getAndVerifyComponentInfo(
+            stakingNftId, 
+            STAKING(),
+            true);
+
+        // effects
+        TokenHandler tokenHandler = IComponent(msg.sender).getTokenHandler();
+        tokenHandler.approve(token, amount);
+    }
 
-        info.wallet = newWallet;
-        instance.getInstanceStore().updateComponent(componentNftId, info, KEEP_STATE());
-        emit LogComponentServiceWalletAddressChanged(componentNftId, currentWallet, newWallet);
+
+    function setWallet(address newWallet)
+        external
+        virtual
+    {
+        // checks
+        (NftId componentNftId,, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
+        TokenHandler tokenHandler = instance.getInstanceReader().getComponentInfo(
+            componentNftId).tokenHandler;
+
+        // effects
+        tokenHandler.setWallet(newWallet);
     }
 
     // TODO implement
@@ -100,7 +155,7 @@ contract ComponentService is
     {
         (NftId componentNftId,, IInstance instance) = _getAndVerifyActiveComponent(COMPONENT());
         IComponents.ComponentInfo memory info = instance.getInstanceReader().getComponentInfo(componentNftId);
-        address componentWallet = info.wallet;
+        address componentWallet = info.tokenHandler.getWallet();
 
         // determine withdrawn amount
         withdrawnAmount = amount;
@@ -115,51 +170,41 @@ contract ComponentService is
             }
         }
 
-        // check allowance
-        TokenHandler tokenHandler = info.tokenHandler;
-        IERC20Metadata token = IERC20Metadata(info.token);
-        uint256 tokenAllowance = token.allowance(componentWallet, address(tokenHandler));
-        if (tokenAllowance < withdrawnAmount.toInt()) {
-            revert ErrorComponentServiceWalletAllowanceTooSmall(componentWallet, address(tokenHandler), tokenAllowance, withdrawnAmount.toInt());
-        }
-
         // decrease fee counters by withdrawnAmount
         _changeTargetBalance(DECREASE, instance.getInstanceStore(), componentNftId, AmountLib.zero(), withdrawnAmount);
         
         // transfer amount to component owner
         address componentOwner = getRegistry().ownerOf(componentNftId);
-        // TODO: centralize token handling (issue #471)
-        tokenHandler.transfer(componentWallet, componentOwner, withdrawnAmount);
-
-        emit LogComponentServiceComponentFeesWithdrawn(componentNftId, componentOwner, address(token), withdrawnAmount);
+        emit LogComponentServiceComponentFeesWithdrawn(componentNftId, componentOwner, address(info.token), withdrawnAmount);
+        info.tokenHandler.distributeTokens(componentWallet, componentOwner, withdrawnAmount);
     }
 
 
     //-------- product ------------------------------------------------------//
 
-    function registerProduct()
+    function registerProduct(address productAddress)
         external
         virtual
+        onlyComponent(productAddress)
+        returns (NftId productNftId)
     {
-        address contractAddress = 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);
-
-        // link distribution and pool to product
-        _linkToProduct(instanceReader, instanceStore, productInfo.distributionNftId, productNftId);
-        _linkToProduct(instanceReader, instanceStore, productInfo.poolNftId, productNftId);
+        InstanceAdmin instanceAdmin;
+        InstanceStore instanceStore;
+        (, instanceAdmin, instanceStore,, productNftId) = _register(
+            productAddress,
+            PRODUCT());
+
+        // get product
+        IProductComponent product = IProductComponent(productAddress);
+
+        // create info
+        instanceStore.createProduct(
+            productNftId, 
+            product.getInitialProductInfo());
+
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(product);
     }
 
 
@@ -204,6 +249,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(productNftId, PRODUCT());
         _changeTargetBalance(INCREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
     }
 
@@ -214,23 +260,43 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(productNftId, PRODUCT());
         _changeTargetBalance(DECREASE, instanceStore, productNftId, AmountLib.zero(), feeAmount);
     }
 
     //-------- distribution -------------------------------------------------//
 
     /// @dev registers the sending component as a distribution component
-    function registerDistribution()
-        external
+    function _registerDistribution(address distributioAddress)
+        internal
         virtual
+        returns (NftId distributionNftId)
     {
-        address contractAddress = msg.sender;
-
         // register/create component info
-        _register(
-            contractAddress,
-            DISTRIBUTION(),
-            DISTRIBUTION_OWNER_ROLE());
+        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);
+        }
+        if (productInfo.distributionNftId.gtz()) {
+            revert ErrorProductServiceDistributionAlreadyRegistered(productNftId, productInfo.distributionNftId);
+        }
+
+        // set distribution in product info
+        productInfo.distributionNftId = distributionNftId;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(
+            IInstanceLinkedComponent(distributioAddress));
     }
 
 
@@ -277,6 +343,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(distributionNftId, DISTRIBUTION());
         _changeTargetBalance(INCREASE, instanceStore, distributionNftId, amount, feeAmount);
     }
 
@@ -292,6 +359,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(distributionNftId, DISTRIBUTION());
         _changeTargetBalance(DECREASE, instanceStore, distributionNftId, amount, feeAmount);
     }
 
@@ -308,6 +376,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(distributorNftId, DISTRIBUTOR());
         _changeTargetBalance(INCREASE, instanceStore, distributorNftId, amount, feeAmount);
     }
 
@@ -322,51 +391,81 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(distributorNftId, DISTRIBUTOR());
         _changeTargetBalance(DECREASE, instanceStore, distributorNftId, amount, feeAmount);
     }
 
     //-------- oracle -------------------------------------------------------//
 
-    function registerOracle()
-        external
+    function _registerOracle(address oracleAddress)
+        internal
         virtual
+        returns (NftId oracleNftId)
     {
-        address contractAddress = msg.sender;
-
         // register/create component setup
-        (
-            , // instance reader
-            InstanceStore instanceStore, 
-            NftId componentNftId
-        ) = _register(
-            contractAddress,
-            ORACLE(),
-            ORACLE_OWNER_ROLE());            
+        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);
+        }
+        if (productInfo.numberOfOracles == productInfo.expectedNumberOfOracles) {
+            revert ErrorProductServiceOraclesAlreadyRegistered(productNftId, productInfo.expectedNumberOfOracles);
+        }
+
+        // update/add oracle to product info
+        productInfo.oracleNftId[productInfo.numberOfOracles] = oracleNftId;
+        productInfo.numberOfOracles++;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(
+            IInstanceLinkedComponent(oracleAddress));
     }
 
     //-------- pool ---------------------------------------------------------//
 
-    function registerPool()
-        external
+    function _registerPool(address poolAddress)
+        internal
         virtual
+        returns (NftId poolNftId)
     {
-        address contractAddress = msg.sender;
-
         // register/create component setup
-        (
-            , // instance reader
-            InstanceStore instanceStore, 
-            NftId componentNftId
-        ) = _register(
-            contractAddress,
-            POOL(),
-            POOL_OWNER_ROLE());            
+        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);
+        if (productInfo.poolNftId.gtz()) {
+            revert ErrorProductServicePoolAlreadyRegistered(productNftId, productInfo.poolNftId);
+        }
 
         // create info
+        IPoolComponent pool = IPoolComponent(poolAddress);
         instanceStore.createPool(
-            componentNftId, 
-            IPoolComponent(
-                contractAddress).getInitialPoolInfo());
+            poolNftId, 
+            pool.getInitialPoolInfo());
+
+        // update pool in product info
+        productInfo.poolNftId = poolNftId;
+        instanceStore.updateProduct(productNftId, productInfo, KEEP_STATE());
+
+        // authorize
+        instanceAdmin.initializeComponentAuthorization(pool);
     }
 
 
@@ -421,6 +520,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(poolNftId, POOL());
         _changeTargetBalance(INCREASE, instanceStore, poolNftId, amount, feeAmount);
     }
 
@@ -435,6 +535,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(poolNftId, POOL());
         _changeTargetBalance(DECREASE, instanceStore, poolNftId, amount, feeAmount);
     }
 
@@ -451,6 +552,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
         _changeTargetBalance(INCREASE, instanceStore, bundleNftId, amount, feeAmount);
     }
 
@@ -465,6 +567,7 @@ contract ComponentService is
         // TODO re-enable once role granting is stable and fixed
         // restricted()
     {
+        _checkNftType(bundleNftId, BUNDLE());
         _changeTargetBalance(DECREASE, instanceStore, bundleNftId, amount, feeAmount);
     }
 
@@ -492,74 +595,72 @@ contract ComponentService is
         }
     }
 
-    /// @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
+        ObjectType requiredType // required type for component for registration
     )
         internal
         virtual
         returns (
             InstanceReader instanceReader, 
+            InstanceAdmin instanceAdmin, 
             InstanceStore instanceStore, 
+            NftId parentNftId,
             NftId componentNftId
         )
     {
+        NftId instanceNftId;
+        IInstance instance;
+        IInstanceLinkedComponent component;
+        address initialOwner;
+
         (
-            IInstance instance,
-            IInstanceLinkedComponent component,
-            address owner
+            instanceNftId, 
+            instance, 
+            parentNftId, 
+            component, 
+            initialOwner
         ) = _getAndVerifyRegisterableComponent(
+            getRegistry(),
             componentAddress,
-            requiredType,
-            requiredRole);
-
-        // register component with registry
-        componentNftId = _registryService.registerComponent(
-            component, 
-            requiredType, 
-            owner).nftId;
-
-        component.linkToRegisteredNftId();
-
-        // setup initial component authorization
-        _instanceService.initializeAuthorization(
-            instance.getNftId(),
-            component);
+            requiredType);
 
-        // save amended component info with instance
+        // get instance supporting contracts (as function return values)
         instanceReader = instance.getInstanceReader();
+        instanceAdmin = instance.getInstanceAdmin();
         instanceStore = instance.getInstanceStore();
 
-        IComponents.ComponentInfo memory componentInfo = component.getComponentInfo();
-        componentInfo.tokenHandler = new TokenHandler(address(componentInfo.token));
+        // register with registry
+        if (requiredType == PRODUCT()) {
+            componentNftId = _registryService.registerProduct(
+                component, initialOwner).nftId;
+        } else {
+            componentNftId = _registryService.registerProductLinkedComponent(
+                component, requiredType, initialOwner).nftId;
+        }
+
+        // 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()));
+        
+        // set token handler allowance to max
+        // componentInfo.tokenHandler.approve(token, AmountLib.max());
 
+        // register component with instance
         instanceStore.createComponent(
-            component.getNftId(), 
+            componentNftId, 
             componentInfo);
 
-        // TODO add logging
-    }
-
+        // link component contract to nft id
+        component.linkToRegisteredNftId();
 
-    /// @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(instanceNftId, componentNftId, requiredType, address(component), address(token), initialOwner);
     }
 
 
@@ -578,12 +679,6 @@ contract ComponentService is
     }
 
 
-    function _createSelectors(bytes4 selector) internal pure returns (bytes4[] memory selectors) {
-        selectors = new bytes4[](1);
-        selectors[0] = selector;
-    }
-
-
     function _getLinkedProductInfo(
         InstanceReader instanceReader, 
         NftId componentNftId
@@ -595,56 +690,89 @@ contract ComponentService is
             IComponents.ProductInfo memory info
         )
     {
-        productNftId = instanceReader.getComponentInfo(componentNftId).productNftId;
+        productNftId = _getProductNftId(componentNftId);
         info = instanceReader.getProductInfo(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 sender is not registered
     /// - 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 has already been registered
     function _getAndVerifyRegisterableComponent(
+        IRegistry registry,
         address componentAddress,
-        ObjectType requiredType,
-        RoleId requiredRole
+        ObjectType requiredType
     )
         internal
         view
         returns (
+            NftId instanceNftId,
             IInstance instance,
+            NftId parentNftId,
             IInstanceLinkedComponent component,
-            address owner
+            address initialOwner
         )
     {
-        // check this is a component
-        component = IInstanceLinkedComponent(componentAddress);
-        if(!component.supportsInterface(type(IInstanceLinkedComponent).interfaceId)) {
-            revert ErrorComponentServiceNotComponent(componentAddress);
+        // 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().getNftId(componentAddress).gtz()) {
+        if (getRegistry().getNftIdForAddress(componentAddress).gtz()) {
             revert ErrorComponentServiceAlreadyRegistered(componentAddress);
         }
 
-        // check instance has assigned required role to inital owner
-        instance = _getInstance(info.parentNftId);
-        owner = info.initialOwner;
+        // check release matches
+        address parentAddress = registry.getObjectAddress(parentNftId);
+        if (component.getRelease() != IRegisterable(parentAddress).getRelease()) {
+            revert ErrorComponentServiceReleaseMismatch(componentAddress, component.getRelease(), IRegisterable(parentAddress).getRelease());
+        }
+
+        // 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);
+        }
+
+        // verify parent is registered instance
+        if (requiredType == PRODUCT()) {
+            if (senderInfo.objectType != INSTANCE()) {
+                revert ErrorComponentServiceParentNotInstance(senderInfo.nftId, senderInfo.objectType);
+            }
 
-        if(!instance.getInstanceAdmin().hasRole(owner, requiredRole)) {
-            revert ErrorComponentServiceExpectedRoleMissing(info.parentNftId, requiredRole, owner);
+            instanceNftId = senderInfo.nftId;
+        // verify parent is registered product
+        } else {
+            if (senderInfo.objectType != PRODUCT()) {
+                revert ErrorComponentServiceParentNotProduct(senderInfo.nftId, senderInfo.objectType);
+            }
+
+            instanceNftId = senderInfo.parentNftId;
         }
+
+        // get initial owner and instance
+        initialOwner = info.initialOwner;
+        instance = _getInstance(registry, instanceNftId);
     }
 
+
     function _getDomain() internal pure virtual override returns(ObjectType) {
         return COMPONENT();
     }