@etherisc/gif-next 0.0.2-9c44ae6-473 → 0.0.2-9d3eab3-323

package/contracts/instance/InstanceService.sol

@@ -2,40 +2,37 @@
 pragma solidity ^0.8.20;
 
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
+import {AccessManagerUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagerUpgradeable.sol";
 
-import {AccessManagerSimple} from "./AccessManagerSimple.sol";
-import {InstanceAccessManager} from "./InstanceAccessManager.sol";
+import {AccessManagerUpgradeableInitializeable} from "./AccessManagerUpgradeableInitializeable.sol";
 import {Instance} from "./Instance.sol";
 import {IInstanceService} from "./IInstanceService.sol";
 import {InstanceReader} from "./InstanceReader.sol";
 import {BundleManager} from "./BundleManager.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
-import {Registry} from "../registry/Registry.sol";
 import {RegistryService} from "../registry/RegistryService.sol";
 import {Service} from "../../contracts/shared/Service.sol";
 import {IService} from "../shared/IService.sol";
-import {ContractDeployerLib} from "../shared/ContractDeployerLib.sol";
-import {NftId, NftIdLib, zeroNftId} from "../../contracts/types/NftId.sol";
+import {NftId} from "../../contracts/types/NftId.sol";
 import {RoleId} from "../types/RoleId.sol";
 import {VersionLib} from "../types/Version.sol";
-import {ADMIN_ROLE, INSTANCE_SERVICE_ROLE, DISTRIBUTION_SERVICE_ROLE, POOL_SERVICE_ROLE, PRODUCT_SERVICE_ROLE} from "../types/RoleId.sol";
+import {ADMIN_ROLE, INSTANCE_SERVICE_ROLE, DISTRIBUTION_SERVICE_ROLE, POOL_SERVICE_ROLE, PRODUCT_SERVICE_ROLE, POLICY_SERVICE_ROLE, BUNDLE_SERVICE_ROLE} from "../types/RoleId.sol";
+import {ObjectType, INSTANCE, SERVICE, PRODUCT, POOL, DISTRIBUTION, POLICY, BUNDLE} from "../types/ObjectType.sol";
 
 contract InstanceService is Service, IInstanceService {
 
-    address internal _registryAddress;
-    address internal _accessManagerMaster;
-    address internal _instanceMaster;
-    address internal _instanceReaderMaster;
-    address internal _instanceBundleManagerMaster;
+    address internal _masterInstanceAccessManager;
+    address internal _masterInstance;
+    address internal _masterInstanceReader;
+    address internal _masterInstanceBundleManager;
 
     // TODO update to real hash when instance is stable
     bytes32 public constant INSTANCE_CREATION_CODE_HASH = bytes32(0);
-    string public constant NAME = "InstanceService";
 
     function createInstanceClone()
         external 
         returns (
-            AccessManagerSimple clonedAccessManager, 
+            AccessManagerUpgradeableInitializeable clonedAccessManager, 
             Instance clonedInstance,
             NftId clonedInstanceNftId,
             InstanceReader clonedInstanceReader,
@@ -43,28 +40,29 @@ contract InstanceService is Service, IInstanceService {
         )
     {
         address instanceOwner = msg.sender;
-        Registry registry = Registry(_registryAddress);
-        NftId registryNftId = registry.getNftId(_registryAddress);
-        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        IRegistry registry = getRegistry();
+        address registryAddress = address(registry);
+        NftId registryNftId = registry.getNftId(registryAddress);
+        address registryServiceAddress = registry.getServiceAddress(SERVICE(), VersionLib.toVersion(3, 0, 0).toMajorPart());
         RegistryService registryService = RegistryService(registryServiceAddress);
 
         // initially set the authority of the access managar to this (being the instance service). 
         // This will allow the instance service to bootstrap the authorizations of the instance
         // and then transfer the ownership of the access manager to the instance owner once everything is setup
-        clonedAccessManager = AccessManagerSimple(Clones.clone(_accessManagerMaster));
-        clonedAccessManager.initialize(address(this));
+        clonedAccessManager = AccessManagerUpgradeableInitializeable(Clones.clone(_masterInstanceAccessManager));
+        clonedAccessManager.__AccessManagerUpgradeableInitializeable_init(address(this));
 
-        clonedInstance = Instance(Clones.clone(_instanceMaster));
-        clonedInstance.initialize(address(clonedAccessManager), _registryAddress, registryNftId, msg.sender);
+        clonedInstance = Instance(Clones.clone(_masterInstance));
+        clonedInstance.initialize(address(clonedAccessManager), registryAddress, registryNftId, msg.sender);
         ( IRegistry.ObjectInfo memory info, ) = registryService.registerInstance(clonedInstance);
         clonedInstanceNftId = info.nftId;
         
-        clonedInstanceReader = InstanceReader(Clones.clone(address(_instanceReaderMaster)));
-        clonedInstanceReader.initialize(_registryAddress, clonedInstanceNftId);
+        clonedInstanceReader = InstanceReader(Clones.clone(address(_masterInstanceReader)));
+        clonedInstanceReader.initialize(registryAddress, clonedInstanceNftId);
         clonedInstance.setInstanceReader(clonedInstanceReader);
 
-        clonedBundleManager = BundleManager(Clones.clone(_instanceBundleManagerMaster));
-        clonedBundleManager.initialize(address(clonedAccessManager), _registryAddress, clonedInstanceNftId);
+        clonedBundleManager = BundleManager(Clones.clone(_masterInstanceBundleManager));
+        clonedBundleManager.initialize(address(clonedAccessManager), registryAddress, clonedInstanceNftId);
         clonedInstance.setBundleManager(clonedBundleManager);
 
         // TODO amend setters with instance specific , policy manager ...
@@ -79,9 +77,19 @@ contract InstanceService is Service, IInstanceService {
         emit LogInstanceCloned(address(clonedAccessManager), address(clonedInstance), address(clonedInstanceReader), clonedInstanceNftId);
     }
 
-    function _grantInitialAuthorizations(AccessManagerSimple clonedAccessManager, Instance clonedInstance, BundleManager clonedBundleManager) internal {
+    function _grantInitialAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance, BundleManager clonedBundleManager) internal {
+        _grantRegistryServiceAuthorizations(clonedAccessManager, clonedInstance);
+        _grantPoolServiceAuthorizations(clonedAccessManager, clonedInstance);
+        _grantProductServiceAuthorizations(clonedAccessManager, clonedInstance);
+        _grantPolicyServiceAuthorizations(clonedAccessManager, clonedInstance);    
+        _grantBundleServiceAuthorizations(clonedAccessManager, clonedInstance, clonedBundleManager);
+        _grantInstanceServiceAuthorizations(clonedAccessManager, clonedInstance);
+    }
+
+    function _grantRegistryServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance) internal {
         // configure authorization for distribution service on instance
-        address distributionServiceAddress = _registry.getServiceAddress("DistributionService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        IRegistry registry = getRegistry();
+        address distributionServiceAddress = registry.getServiceAddress(DISTRIBUTION(), VersionLib.toVersion(3, 0, 0).toMajorPart());
         clonedAccessManager.grantRole(DISTRIBUTION_SERVICE_ROLE().toInt(), distributionServiceAddress, 0);
         bytes4[] memory instanceDistributionServiceSelectors = new bytes4[](2);
         instanceDistributionServiceSelectors[0] = clonedInstance.createDistributionSetup.selector;
@@ -90,97 +98,157 @@ contract InstanceService is Service, IInstanceService {
             address(clonedInstance),
             instanceDistributionServiceSelectors, 
             DISTRIBUTION_SERVICE_ROLE().toInt());
+    }
 
+    function _grantPoolServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance) internal {
         // configure authorization for pool service on instance
-        address poolServiceAddress = _registry.getServiceAddress("PoolService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        address poolServiceAddress = _registry.getServiceAddress(POOL(), VersionLib.toVersion(3, 0, 0).toMajorPart());
         clonedAccessManager.grantRole(POOL_SERVICE_ROLE().toInt(), address(poolServiceAddress), 0);
         bytes4[] memory instancePoolServiceSelectors = new bytes4[](4);
         instancePoolServiceSelectors[0] = clonedInstance.createPoolSetup.selector;
         instancePoolServiceSelectors[1] = clonedInstance.updatePoolSetup.selector;
-        instancePoolServiceSelectors[2] = clonedInstance.createBundle.selector;
-        instancePoolServiceSelectors[3] = clonedInstance.updateBundle.selector;
         clonedAccessManager.setTargetFunctionRole(
             address(clonedInstance),
             instancePoolServiceSelectors, 
             POOL_SERVICE_ROLE().toInt());
-        
-        // configure authorization for pool service on bundle manager
-        bytes4[] memory bundleManagerPoolServiceSelectors = new bytes4[](5);
-        bundleManagerPoolServiceSelectors[0] = clonedBundleManager.linkPolicy.selector;
-        bundleManagerPoolServiceSelectors[1] = clonedBundleManager.unlinkPolicy.selector;
-        bundleManagerPoolServiceSelectors[2] = clonedBundleManager.add.selector;
-        bundleManagerPoolServiceSelectors[3] = clonedBundleManager.lock.selector;
-        bundleManagerPoolServiceSelectors[4] = clonedBundleManager.unlock.selector;
-        clonedAccessManager.setTargetFunctionRole(
-            address(clonedBundleManager),
-            bundleManagerPoolServiceSelectors, 
-            POOL_SERVICE_ROLE().toInt());
+    }
 
+    function _grantProductServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance) internal {
         // configure authorization for product service on instance
-        address productServiceAddress = _registry.getServiceAddress("ProductService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        address productServiceAddress = _registry.getServiceAddress(PRODUCT(), VersionLib.toVersion(3, 0, 0).toMajorPart());
         clonedAccessManager.grantRole(PRODUCT_SERVICE_ROLE().toInt(), address(productServiceAddress), 0);
-        bytes4[] memory instanceProductServiceSelectors = new bytes4[](9);
+        bytes4[] memory instanceProductServiceSelectors = new bytes4[](5);
         instanceProductServiceSelectors[0] = clonedInstance.createProductSetup.selector;
         instanceProductServiceSelectors[1] = clonedInstance.updateProductSetup.selector;
         instanceProductServiceSelectors[2] = clonedInstance.createRisk.selector;
         instanceProductServiceSelectors[3] = clonedInstance.updateRisk.selector;
         instanceProductServiceSelectors[4] = clonedInstance.updateRiskState.selector;
-        instanceProductServiceSelectors[5] = clonedInstance.createPolicy.selector;
-        instanceProductServiceSelectors[6] = clonedInstance.updatePolicy.selector;
-        instanceProductServiceSelectors[7] = clonedInstance.updatePolicyState.selector;
         clonedAccessManager.setTargetFunctionRole(
             address(clonedInstance),
             instanceProductServiceSelectors, 
             PRODUCT_SERVICE_ROLE().toInt());
     }
 
-    function setAccessManagerMaster(address accessManagerMaster) external {
-        require(
-            _accessManagerMaster == address(0),
-            "ERROR:CRD-001:ACCESS_MANAGER_MASTER_ALREADY_SET");
-        _accessManagerMaster = accessManagerMaster;
+    function _grantPolicyServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance) internal {
+        // configure authorization for policy service on instance
+        address policyServiceAddress = _registry.getServiceAddress(POLICY(), VersionLib.toVersion(3, 0, 0).toMajorPart());
+        clonedAccessManager.grantRole(POLICY_SERVICE_ROLE().toInt(), address(policyServiceAddress), 0);
+        bytes4[] memory instancePolicyServiceSelectors = new bytes4[](3);
+        instancePolicyServiceSelectors[0] = clonedInstance.createPolicy.selector;
+        instancePolicyServiceSelectors[1] = clonedInstance.updatePolicy.selector;
+        instancePolicyServiceSelectors[2] = clonedInstance.updatePolicyState.selector;
+        clonedAccessManager.setTargetFunctionRole(
+            address(clonedInstance),
+            instancePolicyServiceSelectors, 
+            POLICY_SERVICE_ROLE().toInt());
+    }
+
+    function _grantBundleServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance, BundleManager clonedBundleManager) internal {
+        // configure authorization for bundle service on instance
+        address bundleServiceAddress = _registry.getServiceAddress(BUNDLE(), VersionLib.toVersion(3, 0, 0).toMajorPart());
+        clonedAccessManager.grantRole(BUNDLE_SERVICE_ROLE().toInt(), address(bundleServiceAddress), 0);
+        bytes4[] memory instanceBundleServiceSelectors = new bytes4[](2);
+        instanceBundleServiceSelectors[0] = clonedInstance.createBundle.selector;
+        instanceBundleServiceSelectors[1] = clonedInstance.updateBundle.selector;
+        clonedAccessManager.setTargetFunctionRole(
+            address(clonedInstance),
+            instanceBundleServiceSelectors, 
+            BUNDLE_SERVICE_ROLE().toInt());
+
+        // configure authorization for bundle service on bundle manager
+        bytes4[] memory bundleManagerBundleServiceSelectors = new bytes4[](5);
+        bundleManagerBundleServiceSelectors[0] = clonedBundleManager.linkPolicy.selector;
+        bundleManagerBundleServiceSelectors[1] = clonedBundleManager.unlinkPolicy.selector;
+        bundleManagerBundleServiceSelectors[2] = clonedBundleManager.add.selector;
+        bundleManagerBundleServiceSelectors[3] = clonedBundleManager.lock.selector;
+        bundleManagerBundleServiceSelectors[4] = clonedBundleManager.unlock.selector;
+        clonedAccessManager.setTargetFunctionRole(
+            address(clonedBundleManager),
+            bundleManagerBundleServiceSelectors, 
+            BUNDLE_SERVICE_ROLE().toInt());
+    }
+
+    function _grantInstanceServiceAuthorizations(AccessManagerUpgradeable clonedAccessManager, Instance clonedInstance) internal {
+// configure authorization for instance service on instance
+        address instanceServiceAddress = _registry.getServiceAddress(INSTANCE(), VersionLib.toVersion(3, 0, 0).toMajorPart());
+        clonedAccessManager.grantRole(INSTANCE_SERVICE_ROLE().toInt(), instanceServiceAddress, 0);
+        bytes4[] memory instanceInstanceServiceSelectors = new bytes4[](1);
+        instanceInstanceServiceSelectors[0] = clonedInstance.setInstanceReader.selector;
+        clonedAccessManager.setTargetFunctionRole(
+            address(clonedInstance),
+            instanceInstanceServiceSelectors, 
+            INSTANCE_SERVICE_ROLE().toInt());
     }
 
-    function setInstanceMaster(address instanceMaster) external {
-        require(
-            _instanceMaster == address(0),
-            "ERROR:CRD-002:INSTANCE_MASTER_ALREADY_SET");
-        _instanceMaster = instanceMaster;
+    function setMasterInstance(address accessManagerAddress, address instanceAddress, address instanceReaderAddress, address bundleManagerAddress) external onlyOwner {
+        require(_masterInstanceAccessManager == address(0), "ERROR:CRD-001:ACCESS_MANAGER_MASTER_ALREADY_SET");
+        require(_masterInstance == address(0), "ERROR:CRD-002:INSTANCE_MASTER_ALREADY_SET");
+        require(_masterInstanceBundleManager == address(0), "ERROR:CRD-004:BUNDLE_MANAGER_MASTER_ALREADY_SET");
+
+        require (accessManagerAddress != address(0), "ERROR:CRD-005:ACCESS_MANAGER_ZERO");
+        require (instanceAddress != address(0), "ERROR:CRD-006:INSTANCE_ZERO");
+        require (instanceReaderAddress != address(0), "ERROR:CRD-007:INSTANCE_READER_ZERO");
+        require (bundleManagerAddress != address(0), "ERROR:CRD-008:BUNDLE_MANAGER_ZERO");
+
+        Instance instance = Instance(instanceAddress);
+        InstanceReader instanceReader = InstanceReader(instanceReaderAddress);
+        BundleManager bundleManager = BundleManager(bundleManagerAddress);
+
+        require(instance.authority() == accessManagerAddress, "ERROR:CRD-009:INSTANCE_AUTHORITY_MISMATCH");
+        require(instanceReader.getInstanceNftId() == instance.getNftId(), "ERROR:CRD-010:INSTANCE_READER_INSTANCE_MISMATCH");
+        require(bundleManager.getInstanceNftId() == instance.getNftId(), "ERROR:CRD-011:BUNDLE_MANAGER_INSTANCE_MISMATCH");
+
+        _masterInstanceAccessManager = accessManagerAddress;
+        _masterInstance = instanceAddress;
+        _masterInstanceReader = instanceReaderAddress;
+        _masterInstanceBundleManager = bundleManagerAddress;
     }
 
-    function setInstanceReaderMaster(address instanceReaderMaster) external {
-        require(
-            _instanceReaderMaster == address(0),
-            "ERROR:CRD-003:INSTANCE_READER_MASTER_ALREADY_SET");
-        _instanceReaderMaster = instanceReaderMaster;
+    function setMasterInstanceReader(address instanceReaderAddress) external onlyOwner {
+        require(_masterInstanceReader != address(0), "ERROR:CRD-003:INSTANCE_READER_MASTER_NOT_SET");
+        require (instanceReaderAddress != address(0), "ERROR:CRD-012:INSTANCE_READER_ZERO");
+        require(instanceReaderAddress != _masterInstanceReader, "ERROR:CRD-014:INSTANCE_READER_MASTER_SAME_AS_NEW");
+
+        InstanceReader instanceReader = InstanceReader(instanceReaderAddress);
+        require(instanceReader.getInstanceNftId() == Instance(_masterInstance).getNftId(), "ERROR:CRD-015:INSTANCE_READER_INSTANCE_MISMATCH");
+
+        _masterInstanceReader = instanceReaderAddress;
     }
 
-    function setBundleManagerMaster(address bundleManagerMaster) external {
-        require(
-            _instanceBundleManagerMaster == address(0),
-            "ERROR:CRD-004:BUNDLE_MANAGER_MASTER_ALREADY_SET");
-        _instanceBundleManagerMaster = bundleManagerMaster;
+    function upgradeInstanceReader(NftId instanceNftId) external {
+        IRegistry registry = getRegistry();
+        IRegistry.ObjectInfo memory instanceInfo = registry.getObjectInfo(instanceNftId);
+        Instance instance = Instance(instanceInfo.objectAddress);
+        address owner = instance.getOwner();
+
+        if (msg.sender != owner) {
+            revert ErrorInstanceServiceRequestUnauhorized(msg.sender);
+        }
+        
+        InstanceReader upgradedInstanceReaderClone = InstanceReader(Clones.clone(address(_masterInstanceReader)));
+        upgradedInstanceReaderClone.initialize(address(registry), instanceNftId);
+        instance.setInstanceReader(upgradedInstanceReaderClone);
     }
 
-    function getInstanceReaderMaster() external view returns (address) {
-        return _instanceReaderMaster;
+    function getMasterInstanceReader() external view returns (address) {
+        return _masterInstanceReader;
     }
 
-    function getInstanceMaster() external view returns (address) {
-        return _instanceMaster;
+    function getMasterInstance() external view returns (address) {
+        return _masterInstance;
     }
 
-    function getAccessManagerMaster() external view returns (address) {
-        return _accessManagerMaster;
+    function getMasterInstanceAccessManager() external view returns (address) {
+        return _masterInstanceAccessManager;
     }
 
-    function getBundleManagerMaster() external view returns (address) {
-        return _instanceBundleManagerMaster;
+    function getMasterInstanceBundleManager() external view returns (address) {
+        return _masterInstanceBundleManager;
     }
 
     // From IService
-    function getName() public pure override(IService, Service) returns(string memory) {
-        return NAME;
+    function getDomain() public pure override(Service, IService) returns(ObjectType) {
+        return INSTANCE();
     }
     
     /// @dev top level initializer
@@ -196,32 +264,31 @@ contract InstanceService is Service, IInstanceService {
         initializer
         virtual override
     {
-        // bytes memory encodedConstructorArguments = abi.encode(
-        //     _registryAddress);
-
-        // bytes memory instanceCreationCode = ContractDeployerLib.getCreationCode(
-        //     instanceByteCodeWithInitCode,
-        //     encodedConstructorArguments);
-
-        // address instanceAddress = ContractDeployerLib.deploy(
-        //     instanceCreationCode,
-        //     INSTANCE_CREATION_CODE_HASH);
-
         address initialOwner = address(0);
-        (_registryAddress, initialOwner) = abi.decode(data, (address, address));
+        address registryAddress = address(0);
+        (registryAddress, initialOwner) = abi.decode(data, (address, address));
         // TODO while InstanceService is not deployed in InstanceServiceManager constructor
         //      owner is InstanceServiceManager deployer
-        _initializeService(_registryAddress, owner);
+        _initializeService(registryAddress, owner);
         
         _registerInterface(type(IService).interfaceId);
         _registerInterface(type(IInstanceService).interfaceId);
     }
-
-    function hasRole(address account, RoleId role, NftId instanceNftId) external view returns (bool) {
+    // TODO use instanceAddress instead of nft
+    /*function hasRole(address account, RoleId role, NftId instanceNftId) external view returns (bool) {
         IRegistry.ObjectInfo memory instanceObjectInfo = getRegistry().getObjectInfo(instanceNftId);
         address instanceAddress = instanceObjectInfo.objectAddress;
         Instance instance = Instance(instanceAddress);
-        AccessManagerSimple accessManager = AccessManagerSimple(instance.authority());
+        AccessManagerUpgradeable accessManager = AccessManagerUpgradeable(instance.authority());
+        (bool isMember, uint32 executionDelay) = accessManager.hasRole(role.toInt(), account);
+        if (executionDelay > 0) {
+            return false;
+        } 
+        return isMember;
+    }*/
+    function hasRole(address account, RoleId role, address instanceAddress) external view returns (bool) {
+        Instance instance = Instance(instanceAddress);
+        AccessManagerUpgradeable accessManager = AccessManagerUpgradeable(instance.authority());
         (bool isMember, uint32 executionDelay) = accessManager.hasRole(role.toInt(), account);
         if (executionDelay > 0) {
             return false;

package/contracts/instance/InstanceServiceManager.sol

@@ -8,6 +8,7 @@ import {InstanceService} from "./InstanceService.sol";
 import {Registry} from "../registry/Registry.sol";
 import {RegistryService} from "../registry/RegistryService.sol";
 import {VersionLib} from "../types/Version.sol";
+import {SERVICE} from "../types/ObjectType.sol";
 
 contract InstanceServiceManager is ProxyManager {
 
@@ -29,7 +30,7 @@ contract InstanceServiceManager is ProxyManager {
         _instanceService = InstanceService(address(versionable));
 
         Registry registry = Registry(registryAddress);
-        address registryServiceAddress = registry.getServiceAddress("RegistryService", VersionLib.toVersion(3, 0, 0).toMajorPart());
+        address registryServiceAddress = registry.getServiceAddress(SERVICE(), VersionLib.toVersion(3, 0, 0).toMajorPart());
         RegistryService registryService = RegistryService(registryServiceAddress);
         // TODO this must have a role or own nft to register service
         //registryService.registerService(_instanceService);

package/contracts/instance/ObjectManager.sol

@@ -21,6 +21,7 @@ contract ObjectManager is
 
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _activeObjects;
     mapping(NftId compnentNftId => LibNftIdSet.Set objects) internal _allObjects;
+    NftId internal _instanceNftId;
     InstanceReader internal _instanceReader;
 
     constructor() Cloneable() {
@@ -45,7 +46,8 @@ contract ObjectManager is
 
         IInstance instance = IInstance(instanceInfo.objectAddress);
         _instanceReader = instance.getInstanceReader();
-
+        _instanceNftId = instanceNftId;
+        
         emit LogObjectManagerInitialized(instanceNftId, address(_instanceReader));
     }
 
@@ -53,6 +55,10 @@ contract ObjectManager is
         return _instanceReader;
     }
 
+    function getInstanceNftId() external view returns (NftId) {
+        return _instanceNftId;
+    }
+
     function _add(NftId componentNftId, NftId objectNftId) internal {
         LibNftIdSet.Set storage allSet = _allObjects[componentNftId];
         LibNftIdSet.Set storage activeSet = _activeObjects[componentNftId];

package/contracts/instance/base/ComponentServiceBase.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.19;
 import {IRegistry} from "../../registry/IRegistry.sol";
 import {IRegistryService} from "../../registry/IRegistryService.sol";
 import {IInstance} from "../../instance/IInstance.sol";
-import {ObjectType, INSTANCE, PRODUCT, POOL, DISTRIBUTION, ORACLE} from "../../types/ObjectType.sol";
+import {ObjectType, SERVICE, INSTANCE, PRODUCT, POOL, DISTRIBUTION, ORACLE} from "../../types/ObjectType.sol";
 import {NftId, NftIdLib} from "../../types/NftId.sol";
 import {RoleId, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE, DISTRIBUTION_OWNER_ROLE, ORACLE_OWNER_ROLE} from "../../types/RoleId.sol";
 
@@ -20,21 +20,6 @@ abstract contract ComponentServiceBase is Service {
     error ExpectedRoleMissing(RoleId expected, address caller);
     error ComponentTypeInvalid(ObjectType componentType);
 
-    mapping (ObjectType => RoleId) internal _objectTypeToExpectedRole;
-
-    /// @dev modifier to check if caller has a role on the instance the component is registered in
-    modifier onlyComponentOwnerRole(address componentAddress) {
-        BaseComponent component = BaseComponent(componentAddress);
-        ObjectType objectType = _getObjectType(component);
-        RoleId expectedRole = _objectTypeToExpectedRole[objectType];
-
-        address componentOwner = msg.sender;
-        INftOwnable nftOwnable = INftOwnable(address(component.getInstance()));
-        if(! getInstanceService().hasRole(componentOwner, expectedRole, nftOwnable.getNftId())) {
-            revert ExpectedRoleMissing(expectedRole, componentOwner);
-        }
-        _;
-    }
 
     /// @dev modifier to check if caller is a registered service
     modifier onlyService() {
@@ -43,64 +28,19 @@ abstract contract ComponentServiceBase is Service {
         _;
     }
 
-    function _initializeService(
-        address registry, 
-        address initialOwner
-    )
-        internal
-        override
-    {
-        super._initializeService(registry, initialOwner);
-        _objectTypeToExpectedRole[PRODUCT()] = PRODUCT_OWNER_ROLE();
-        _objectTypeToExpectedRole[POOL()] = POOL_OWNER_ROLE();
-        _objectTypeToExpectedRole[DISTRIBUTION()] = DISTRIBUTION_OWNER_ROLE();
-        _objectTypeToExpectedRole[ORACLE()] = ORACLE_OWNER_ROLE();
-    }
+    // view functions
 
-    function getInstanceService() public view returns (InstanceService) {
-        return InstanceService(getRegistry().getServiceAddress("InstanceService", getMajorVersion()));
+    function getRegistryService() public view virtual returns (IRegistryService) {
+        address service = getRegistry().getServiceAddress(SERVICE(), getMajorVersion());
+        return IRegistryService(service);
     }
 
-    function register(address componentAddress) 
-        external 
-        onlyComponentOwnerRole(componentAddress)
-        returns (NftId componentNftId)
-    {
-        address componentOwner = msg.sender;
-        BaseComponent component = BaseComponent(componentAddress);
-        ObjectType objectType = _getObjectType(component);
-        IRegistryService registryService = getRegistryService();
-
-        IRegistry.ObjectInfo memory objInfo;
-        bytes memory initialObjData;
-
-        if (objectType == DISTRIBUTION()) {
-            (objInfo, initialObjData) = registryService.registerDistribution(component, componentOwner);
-        } else if (objectType == PRODUCT()) {
-            (objInfo, initialObjData) = registryService.registerProduct(component, componentOwner);
-        } else if (objectType == POOL()) {
-            (objInfo, initialObjData) = registryService.registerPool(component, componentOwner);
-        // TODO: implement this for oracle - currently missing in registry
-        // } else if (objectType == ORACLE()) {
-        //     (objInfo, initialObjData) = registryService.registerOracle(component, componentOwner);
-        } else {
-            revert ComponentTypeInvalid(objectType);
-        }
-
-        componentNftId = objInfo.nftId;
-        {
-            IInstance instance = _getInstance(objInfo);
-            _finalizeComponentRegistration(componentNftId, initialObjData, instance);
-        }
+    function getInstanceService() public view returns (InstanceService) {
+        return InstanceService(getRegistry().getServiceAddress(INSTANCE(), getMajorVersion()));
     }
 
-    function _finalizeComponentRegistration(NftId componentNftId, bytes memory initialObjData, IInstance instance) internal virtual;
+    // internal view functions
 
-    function _getObjectType(BaseComponent component) internal view returns (ObjectType) {
-        (IRegistry.ObjectInfo memory compInitialInfo, )  = component.getInitialInfo();
-        return compInitialInfo.objectType;
-    }
-    
     function _getInstance(IRegistry.ObjectInfo memory compObjInfo) internal view returns (IInstance) {
         IRegistry registry = getRegistry();
         IRegistry.ObjectInfo memory instanceInfo = registry.getObjectInfo(compObjInfo.parentNftId);
@@ -108,7 +48,8 @@ abstract contract ComponentServiceBase is Service {
     }
 
     function _getAndVerifyComponentInfoAndInstance(
-        ObjectType objectType
+        //address component,
+        ObjectType expectedType
     )
         internal
         view
@@ -117,18 +58,15 @@ abstract contract ComponentServiceBase is Service {
             IInstance instance
         )
     {
-        NftId componentNftId = _registry.getNftId(msg.sender);
-        require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
+        IRegistry registry = getRegistry();
+        //TODO redundant check -> just check type
+        //NftId componentNftId = registry.getNftId(component); 
+        //require(componentNftId.gtz(), "ERROR_COMPONENT_UNKNOWN");
 
-        info = getRegistry().getObjectInfo(componentNftId);
-        require(info.objectType == objectType, "OBJECT_TYPE_INVALID");
+        info = registry.getObjectInfo(msg.sender);
+        require(info.objectType == expectedType, "OBJECT_TYPE_INVALID");
 
-        address instanceAddress = getRegistry().getObjectInfo(info.parentNftId).objectAddress;
+        address instanceAddress = registry.getObjectInfo(info.parentNftId).objectAddress;
         instance = IInstance(instanceAddress);
     }
-
-    function getRegistryService() public view virtual returns (IRegistryService) {
-        address service = getRegistry().getServiceAddress("RegistryService", getMajorVersion());
-        return IRegistryService(service);
-    }
 }