@etherisc/gif-next 0.0.2-9d3eab3-323 → 0.0.2-9f827bd-593

package/contracts/instance/service/IBundleService.sol

@@ -26,12 +26,9 @@ interface IBundleService is IService {
 
     function updateBundle(NftId instanceNftId, NftId bundleNftId, IBundle.BundleInfo memory bundleInfo, StateId state) external;
 
-    function underwritePolicy(IInstance instanceNftId,
-        NftId policyNftId, 
-        NftId bundleNftId, 
-        uint256 collateralAmount,
-        uint256 netPremium
-    ) external;
+    function underwritePolicy(IInstance instanceNftId, NftId policyNftId, NftId bundleNftId, uint256 collateralAmount, uint256 netPremium) external;
+
+    function increaseBalance(IInstance instance, NftId bundleNftId,  uint256 amount) external;
 
     // function fundBundle(NftId bundleNftId, uint256 amount) external returns(uint256 netAmount);
 

package/contracts/instance/service/IPolicyService.sol

@@ -15,6 +15,13 @@ import {Fee} from "../../types/Fee.sol";
 interface IPolicyService is IService {
     
     error ErrorIPolicyServiceInsufficientAllowance(address customer, address tokenHandlerAddress, uint256 amount);
+    error ErrorIPolicyServicePremiumAlreadyPaid(NftId policyNftId, uint256 premiumPaidAmount);
+    error ErrorIPolicyServicePolicyNotActivated(NftId policyNftId);
+    error ErrorIPolicyServicePolicyAlreadyClosed(NftId policyNftId);
+    error ErrorIPolicyServicePolicyNotActive(NftId policyNftId, StateId state);
+    error ErrorIPolicyServicePremiumNotFullyPaid(NftId policyNftId, uint256 premiumAmount, uint256 premiumPaidAmount);
+    error ErrorIPolicyServiceOpenClaims(NftId policyNftId, uint16 openClaimsCount);
+    error ErrorIPolicyServicePolicyHasNotExpired(NftId policyNftId, Timestamp expiredAt);
     
     function calculatePremium(
         RiskId riskId,

package/contracts/instance/service/PolicyService.sol

@@ -20,11 +20,11 @@ import {TokenHandler} from "../../shared/TokenHandler.sol";
 import {IVersionable} from "../../shared/IVersionable.sol";
 import {Versionable} from "../../shared/Versionable.sol";
 
-import {Timestamp, zeroTimestamp} from "../../types/Timestamp.sol";
+import {Timestamp, TimestampLib, zeroTimestamp} from "../../types/Timestamp.sol";
 import {UFixed, UFixedLib} from "../../types/UFixed.sol";
 import {Blocknumber, blockNumber} from "../../types/Blocknumber.sol";
 import {ObjectType, INSTANCE, PRODUCT, POOL, POLICY, BUNDLE} from "../../types/ObjectType.sol";
-import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE} from "../../types/StateId.sol";
+import {APPLIED, UNDERWRITTEN, ACTIVE, KEEP_STATE, CLOSED} from "../../types/StateId.sol";
 import {NftId, NftIdLib, zeroNftId} from "../../types/NftId.sol";
 import {Fee, FeeLib} from "../../types/Fee.sol";
 import {ReferralId} from "../../types/Referral.sol";
@@ -44,6 +44,7 @@ import {IBundleService} from "./IBundleService.sol";
 
 contract PolicyService is ComponentServiceBase, IPolicyService {
     using NftIdLib for NftId;
+    using TimestampLib for Timestamp;
 
     IPoolService internal _poolService;
     IBundleService internal _bundleService;
@@ -81,7 +82,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         (productInfo,) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
         product = Product(productInfo.objectAddress);
     }
-    // TODO no access restrictions
+    // TODO: no access restrictions
     function calculatePremium(
         RiskId riskId,
         uint256 sumInsuredAmount,
@@ -179,7 +180,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         ReferralId referralId
     ) external override returns (NftId policyNftId) {
         (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
-        // TODO add validations (see create bundle in pool service)
+        // TODO: add validations (see create bundle in pool service)
 
         policyNftId = getRegistryService().registerPolicy(
             IRegistry.ObjectInfo(
@@ -224,7 +225,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         instance.createPolicy(policyNftId, policyInfo);
         instance.updatePolicyState(policyNftId, APPLIED());
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function _getAndVerifyUnderwritingSetup(
@@ -384,7 +385,7 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
             }
         }
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function calculateRequiredCollateral(UFixed collateralizationLevel, uint256 sumInsuredAmount) public pure override returns(uint256 collateralAmount) {
@@ -397,28 +398,30 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
         // check caller is registered product
         (IRegistry.ObjectInfo memory productInfo, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
         InstanceReader instanceReader = instance.getInstanceReader();
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
 
-        // TODO: check if not paid
-        // TODO: transfer premium 
-        // TODO: optionally activate
+        if (policyInfo.premiumPaidAmount == policyInfo.premiumAmount) {
+            revert ErrorIPolicyServicePremiumAlreadyPaid(policyNftId, policyInfo.premiumPaidAmount);
+        }
 
-        // // perform actual token transfers (this code is probably not complete)
-        // IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
-        
-        // uint256 premiumAmount = policyInfo.premiumAmount;
-        // _processPremiumByTreasury(instance, productInfo.nftId, policyNftId, premiumAmount);
+        uint256 unpaidPremiumAmount = policyInfo.premiumAmount - policyInfo.premiumPaidAmount;
+
+        uint256 netPremiumAmount = _processPremiumByTreasury(
+                instance, 
+                productInfo.nftId,
+                policyNftId, 
+                unpaidPremiumAmount);
 
-        // // policy level book keeping for premium paid
-        // policyInfo.premiumPaidAmount += premiumAmount;
+        policyInfo.premiumPaidAmount += unpaidPremiumAmount;
 
-        // instance.updatePolicy(policyNftId, policyInfo, KEEP_STATE());
+        _bundleService.increaseBalance(instance, policyInfo.bundleNftId, netPremiumAmount);
+        instance.updatePolicy(policyNftId, policyInfo, KEEP_STATE());
 
-        // // optional activation of policy
-        // if(activateAt > zeroTimestamp()) {
-        //     activate(policyNftId, activateAt);
-        // }
+        if(activateAt.gtz() && policyInfo.activatedAt.eqz()) {
+            activate(policyNftId, activateAt);
+        }
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function activate(NftId policyNftId, Timestamp activateAt) public override {
@@ -437,14 +440,45 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
 
         instance.updatePolicy(policyNftId, policyInfo, ACTIVE());
 
-        // TODO add logging
+        // TODO: add logging
     }
 
     function close(
         NftId policyNftId
     ) external override // solhint-disable-next-line no-empty-blocks
     {
+        (, IInstance instance) = _getAndVerifyComponentInfoAndInstance(PRODUCT());
+        InstanceReader instanceReader = instance.getInstanceReader();
+
+        IPolicy.PolicyInfo memory policyInfo = instanceReader.getPolicyInfo(policyNftId);
+
+        if (policyInfo.activatedAt.eqz()) {
+            revert ErrorIPolicyServicePolicyNotActivated(policyNftId);
+        }
+
+        StateId state = instanceReader.getPolicyState(policyNftId);
+        if (state != ACTIVE()) {
+            revert ErrorIPolicyServicePolicyNotActive(policyNftId, state);
+        }
+
+        if (policyInfo.closedAt.gtz()) {
+            revert ErrorIPolicyServicePolicyAlreadyClosed(policyNftId);
+        }
+
+        if (policyInfo.premiumAmount != policyInfo.premiumPaidAmount) {
+            revert ErrorIPolicyServicePremiumNotFullyPaid(policyNftId, policyInfo.premiumAmount, policyInfo.premiumPaidAmount);
+        }
+
+        if (policyInfo.openClaimsCount > 0) {
+            revert ErrorIPolicyServiceOpenClaims(policyNftId, policyInfo.openClaimsCount);
+        }
+
+        if (policyInfo.expiredAt.lt(TimestampLib.blockTimestamp()) && policyInfo.payoutAmount < policyInfo.sumInsuredAmount) {
+            revert ErrorIPolicyServicePolicyHasNotExpired(policyNftId, policyInfo.expiredAt);
+        }
 
+        policyInfo.closedAt = TimestampLib.blockTimestamp();
+        instance.updatePolicy(policyNftId, policyInfo, CLOSED());
     }
 
     function _getPoolNftId(
@@ -498,6 +532,6 @@ contract PolicyService is ComponentServiceBase, IPolicyService {
             }
         }
 
-        // TODO add logging
+        // TODO: add logging
     }
 }

package/contracts/instance/service/PoolService.sol

@@ -74,7 +74,7 @@ contract PoolService is
         bytes memory data;
         (info, data) = getRegistryService().registerPool(pool, poolOwner);
 
-        IInstance instance = _getInstance(info);
+        IInstance instance = _getInstance(info.parentNftId);
 
         bool hasRole = getInstanceService().hasRole(
             poolOwner, 
@@ -88,6 +88,8 @@ contract PoolService is
         poolNftId = info.nftId;
         ISetup.PoolSetupInfo memory initialSetup = _decodeAndVerifyPoolSetup(data);
         instance.createPoolSetup(poolNftId, initialSetup);
+
+        getInstanceService().createTarget(_getInstanceNftId(info), poolAddress, pool.getName());
     }
 
     function _decodeAndVerifyPoolSetup(bytes memory data) internal returns(ISetup.PoolSetupInfo memory setup)

package/contracts/instance/service/PoolServiceManager.sol

@@ -6,8 +6,7 @@ import {ProxyManager} from "../../shared/ProxyManager.sol";
 import {PoolService} from "./PoolService.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";
+import {REGISTRY} from "../../types/ObjectType.sol";
 
 contract PoolServiceManager is ProxyManager {
 
@@ -27,10 +26,10 @@ contract PoolServiceManager is ProxyManager {
 
         _poolService = PoolService(address(versionable));
 
-        Registry registry = Registry(registryAddress);
-        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
+        // TODO `this` must have a role or own nft to register service
+        //Registry registry = Registry(registryAddress);
+        //address registryServiceAddress = registry.getServiceAddress(REGISTRY(), _poolService.getMajorVersion());
+        //RegistryService registryService = RegistryService(registryServiceAddress);
         //registryService.registerService(_poolService);
         
         // TODO no nft to link yet
@@ -38,9 +37,6 @@ contract PoolServiceManager is ProxyManager {
         //_linkToNftOwnable(
         //    address(registryAddress),
         //    address(_poolService));
-
-        // implies that after this constructor call only upgrade functionality is available
-        _isDeployed = true;
     }
 
     //--- view functions ----------------------------------------------------//

package/contracts/instance/service/ProductService.sol

@@ -83,7 +83,7 @@ contract ProductService is ComponentServiceBase, IProductService {
         bytes memory data;
         (info, data) = getRegistryService().registerProduct(product, productOwner);
 
-        IInstance instance = _getInstance(info);
+        IInstance instance = _getInstance(info.parentNftId);
         bool hasRole = getInstanceService().hasRole(
             productOwner, 
             PRODUCT_OWNER_ROLE(), 
@@ -96,6 +96,8 @@ contract ProductService is ComponentServiceBase, IProductService {
         productNftId = info.nftId;
         ISetup.ProductSetupInfo memory initialSetup = _decodeAndVerifyProductSetup(data);
         instance.createProductSetup(productNftId, initialSetup);
+
+        getInstanceService().createTarget(_getInstanceNftId(info), productAddress, product.getName());
     }
 
     function _decodeAndVerifyProductSetup(bytes memory data) internal returns(ISetup.ProductSetupInfo memory setup)

package/contracts/registry/IRegistry.sol

@@ -7,11 +7,12 @@ import {ChainNft} from "./ChainNft.sol";
 import {NftId} from "../types/NftId.sol";
 import {ObjectType} from "../types/ObjectType.sol";
 import {VersionPart} from "../types/Version.sol";
+import {Timestamp} from "../types/Timestamp.sol";
 
 interface IRegistry is IERC165 {
 
     event LogRegistration(NftId nftId, NftId parentNftId, ObjectType objectType, bool isInterceptor, address objectAddress, address initialOwner);
-
+    event LogServiceRegistration(VersionPart majorVersion, ObjectType domain);
 
     // register()
     error CallerNotRegistryService();
@@ -19,6 +20,7 @@ interface IRegistry is IERC165 {
 
     // registerService()
     error CallerNotReleaseManager();
+    error ServiceAlreadyRegistered(address service);
 
     // _register()
     error ZeroParentAddress();
@@ -36,7 +38,17 @@ interface IRegistry is IERC165 {
     }// TODO delete nftId and initialOwner(if not used) from struct
     // TODO strong disagree, keep nftId there (lets keep get object info return object consistent)
 
-    function registerService(ObjectInfo memory serviceInfo) external returns(NftId nftId);
+    struct ReleaseInfo {
+        ObjectType[] domains;
+        Timestamp createdAt;
+        //Timestamp updatedAt;
+    }
+
+    function registerService(
+        ObjectInfo memory serviceInfo, 
+        VersionPart serviceVersion, 
+        ObjectType serviceDomain
+    ) external returns(NftId nftId);
 
     function register(ObjectInfo memory info) external returns (NftId nftId);
 
@@ -46,6 +58,8 @@ interface IRegistry is IERC165 {
 
     function getMajorVersion() external view returns (VersionPart);
 
+    function getReleaseInfo(VersionPart version) external view returns (ReleaseInfo memory);
+
     function getObjectCount() external view returns (uint256);
 
     function getNftId() external view returns (NftId nftId);
@@ -67,7 +81,7 @@ interface IRegistry is IERC165 {
     function isRegisteredService(address contractAddress) external view returns (bool);
 
     function getServiceAddress(
-        ObjectType serviceType, 
+        ObjectType serviceDomain, 
         VersionPart releaseVersion
     ) external view returns (address serviceAddress);
 

package/contracts/registry/IRegistryService.sol

@@ -35,7 +35,7 @@ interface IRegistryService is
      struct FunctionConfig
      {
           ObjectType serviceDomain;
-          bytes4[] selector;
+          bytes4 selector;
      }
 
      // TODO used by service -> add owner arg 

package/contracts/registry/Registry.sol

@@ -2,27 +2,23 @@
 pragma solidity ^0.8.20;
 
 
-import {NftId, toNftId, zeroNftId, NftIdLib} from "../types/NftId.sol";
-import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
+import {NftId, toNftId, zeroNftId} from "../types/NftId.sol";
+import {VersionPart} from "../types/Version.sol";
 import {ObjectType, PROTOCOL, REGISTRY, TOKEN, SERVICE, INSTANCE, STAKE, PRODUCT, DISTRIBUTION, ORACLE, POOL, POLICY, BUNDLE} from "../types/ObjectType.sol";
 
-import {IRegisterable} from "../shared/IRegisterable.sol";
-import {IService} from "../shared/IService.sol";
 import {ERC165} from "../shared/ERC165.sol";
 
 import {ChainNft} from "./ChainNft.sol";
 import {IRegistry} from "./IRegistry.sol";
-import {IRegistryService} from "./IRegistryService.sol";
-import {ITransferInterceptor} from "./ITransferInterceptor.sol";
 import {ReleaseManager} from "./ReleaseManager.sol";
 
-// IMPORTANT (OPTION 1)
+// IMPORTANT
 // Each NFT minted by registry is accosiated with:
 // 1) NFT owner
 // 2) registred contract OR object stored in registered (parent) contract
 // Four registration flows:
-// 1) IService address by release manager (SERVICE of type SERVICE aka registry service)
-// 2) IService address by release manager (SERVICE of type !SERVICE aka regular service)
+// 1) IService address by release manager (SERVICE of domain SERVICE aka registry service aka release creation)
+// 2) IService address by release manager (SERVICE of domain !SERVICE aka regular service)
 // 3) IRegisterable address by regular service (INSTANCE, PRODUCT, POOL, DISTRIBUTION, ORACLE)
 // 4) state object by regular service (POLICY, BUNDLE, STAKE)
 
@@ -30,15 +26,15 @@ contract Registry is
     ERC165,
     IRegistry
 {
-    uint256 public constant GIF_MAJOR_VERSION_AT_DEPLOYMENT = 3;
     address public constant NFT_LOCK_ADDRESS = address(0x1);
     uint256 public constant REGISTRY_TOKEN_SEQUENCE_ID = 2;
-    uint256 public constant REGISTRY_SERVICE_TOKEN_SEQUENCE_ID = 3;
     string public constant EMPTY_URI = "";
 
     mapping(NftId nftId => ObjectInfo info) internal _info;
     mapping(address object => NftId nftId) internal _nftIdByAddress;
 
+    mapping(VersionPart version => mapping(ObjectType serviceDomain => address)) _service;
+
     mapping(ObjectType objectType => mapping(
             ObjectType parentType => bool)) internal _isValidContractCombination;
 
@@ -64,12 +60,9 @@ contract Registry is
         _;
     }
 
-    constructor(address releaseManager, VersionPart initialVersion)
+    constructor()
     {
-        require(releaseManager > address(0), "Registry: release manager is 0");
-        require(initialVersion.toInt() > 0, "Registry: initial version is 0");
-
-        _releaseManager = ReleaseManager(releaseManager);
+        _releaseManager = ReleaseManager(msg.sender);
 
         // deploy NFT 
         _chainNft = new ChainNft(address(this));// adds 10kb to deployment size
@@ -84,7 +77,11 @@ contract Registry is
         _registerInterface(type(IRegistry).interfaceId);
     }
 
-    function registerService(ObjectInfo memory info)
+    function registerService(
+        ObjectInfo memory info, 
+        VersionPart version, 
+        ObjectType domain
+    )
         external
         onlyReleaseManager
         returns(NftId nftId)
@@ -95,7 +92,16 @@ contract Registry is
         }
         info.initialOwner = NFT_LOCK_ADDRESS <- if services are access managed
         */
+
+        if(_service[version][domain] > address(0)) {
+            revert ServiceAlreadyRegistered(info.objectAddress);
+        }
+
+        _service[version][domain] = info.objectAddress; // nftId;
+
         nftId = _register(info);
+
+        emit LogServiceRegistration(version, domain);
     }
 
     function register(ObjectInfo memory info)
@@ -132,6 +138,11 @@ contract Registry is
         return _releaseManager.getLatestVersion();
     }
 
+    function getReleaseInfo(VersionPart version) external view returns (ReleaseInfo memory)
+    {
+        return _releaseManager.getReleaseInfo(version);
+    }
+
     function getObjectCount() external view override returns (uint256) {
         return _chainNft.totalSupply();
     }
@@ -173,11 +184,11 @@ contract Registry is
     }
 
     function getServiceAddress(
-        ObjectType serviceType, 
+        ObjectType serviceDomain, 
         VersionPart releaseVersion
     ) external view returns (address)
     {
-        return _releaseManager.getService(releaseVersion, serviceType);
+        return _service[releaseVersion][serviceDomain];
     }
 
     function getChainNft() external view override returns (ChainNft) {

package/contracts/registry/RegistryAccessManager.sol

@@ -4,15 +4,11 @@ pragma solidity ^0.8.20;
 import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 
-import {ContractDeployerLib} from "../shared/ContractDeployerLib.sol";
 import {RoleId, RoleIdLib,
         REGISTRY_SERVICE_MANAGER_ROLE,
         REGISTRY_SERVICE_ADMIN_ROLE,
         RELEASE_MANAGER_ROLE} from "../types/RoleId.sol";
 
-import {Registry} from "./Registry.sol";
-import {IVersionable} from "../shared/IVersionable.sol";
-import {IRegistryService} from "./IRegistryService.sol";
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {ReleaseManager} from "./ReleaseManager.sol";
 
@@ -37,9 +33,12 @@ import {ReleaseManager} from "./ReleaseManager.sol";
 
 contract RegistryAccessManager is AccessManaged
 {
-    uint64 public constant CUSTOM_ROLE_ID_MIN = 1000000;
+    error NotInitialized();
+    error AlreadyInitialized();
+
+    uint64 public constant UNIQUE_ROLE_ID_MIN = 1000000;
     
-    AccessManager private _accessManager;
+    AccessManager private immutable _accessManager;
     address private _releaseManager;
     address private _tokenRegistry;
 
@@ -48,15 +47,15 @@ contract RegistryAccessManager is AccessManaged
 
     modifier onlyOnce() {
         if(_isInitialized) {
-            revert();
-        }
+            revert AlreadyInitialized();
+        } 
         _;
         _isInitialized = true;
     }
 
     modifier onlyInitialized() {
         if(!_isInitialized) {
-            revert();
+            revert NotInitialized();
         }
         _;
     }
@@ -67,7 +66,7 @@ contract RegistryAccessManager is AccessManaged
         _accessManager = new AccessManager(address(this));
         setAuthority(address(_accessManager));
 
-        _idNext = CUSTOM_ROLE_ID_MIN;
+        _idNext = UNIQUE_ROLE_ID_MIN;
 
         _configureAdminRoleInitial();
 
@@ -76,16 +75,16 @@ contract RegistryAccessManager is AccessManaged
         _grantRole(REGISTRY_SERVICE_MANAGER_ROLE(), manager, 0);
     }
 
-    // TODO need release manager authorization to configure roles for service functions and to grant those roles
     function initialize(address releaseManager, address tokenRegistry)
         external 
         restricted // GIF_ADMIN_ROLE
         onlyOnce
     {
-        if(
-            _releaseManager > address(0) ||
-            _tokenRegistry > address(0))
-        { revert(); }
+        require(
+            ReleaseManager(releaseManager).authority() == address(_accessManager),
+            "RegistryAccessManager: release manager authority is invalid");
+        require(tokenRegistry > address(0), "RegistryAccessManager: token registry is 0");
+        //require(tokenRegistry.authority() == address(_accessManager));
 
         _releaseManager = releaseManager;
         _tokenRegistry = tokenRegistry;
@@ -108,13 +107,14 @@ contract RegistryAccessManager is AccessManaged
         onlyInitialized
         returns(RoleId)
     {
+        // TODO questionable check...
         // target is not part of `runtime`
-        if(
-            target == address(this) ||
-            target == address(_accessManager) || 
-            target == _releaseManager || 
-            target == _tokenRegistry)
-        { revert(); }
+        //if(
+        //    target == address(this) ||
+        //    target == address(_accessManager) || 
+        //    target == _releaseManager || 
+        //    target == _tokenRegistry)
+        //{ return TargetInvalid(); }
 
         RoleId roleId = _getNextRoleId();
 
@@ -154,14 +154,14 @@ contract RegistryAccessManager is AccessManaged
     {
         bytes4[] memory functionSelector = new bytes4[](1);
 
-        // REGISTRY_SERVICE_ADMIN_ROLE for RegistryServiceProxyManager
+        // for RegistryServiceProxyManager
         // TODO upgrading with releaseManager.upgrade()->proxy.upgrade()???
         //functionSelector[0] = RegistryServiceManager.upgrade.selector;
         //_setTargetFunctionRole(address(this), functionSelector, REGISTRY_SERVICE_ADMIN_ROLE());
 
-        // REGISTRY_SERVICE_ADMIN_ROLE for TokenRegistry
+        // for TokenRegistry
 
-        // REGISTRY_SERVICE_ADMIN_ROLE for ReleaseManager
+        // for ReleaseManager
         functionSelector[0] = ReleaseManager.createNextRelease.selector;
         _setTargetFunctionRole(_releaseManager, functionSelector, REGISTRY_SERVICE_ADMIN_ROLE());
         //functionSelector[0] = ReleaseManager.activateNextRelease.selector;
@@ -172,15 +172,15 @@ contract RegistryAccessManager is AccessManaged
     {
         bytes4[] memory functionSelector = new bytes4[](1);
 
-        // REGISTRY_SERVICE_MANAGER_ROLE for TokenRegistry
+        // for TokenRegistry
         functionSelector[0] = TokenRegistry.setActive.selector;
         _setTargetFunctionRole(address(_tokenRegistry), functionSelector, REGISTRY_SERVICE_MANAGER_ROLE());
 
-        // REGISTRY_SERVICE_MANAGER_ROLE for ReleaseManager
+        // for ReleaseManager
         functionSelector[0] = ReleaseManager.registerService.selector;
         _setTargetFunctionRole(_releaseManager, functionSelector, REGISTRY_SERVICE_MANAGER_ROLE());
 
-        // set REGISTRY_SERVICE_ADMIN_ROLE as admin for REGISTRY_SERVICE_MANAGER_ROLE
+        // set admin
         _setRoleAdmin(REGISTRY_SERVICE_MANAGER_ROLE(), REGISTRY_SERVICE_ADMIN_ROLE());
     }
 

package/contracts/registry/RegistryService.sol

@@ -156,7 +156,7 @@ contract RegistryService is
 
     // From IService
     function getDomain() public pure override(IService, Service) returns(ObjectType serviceDomain) {
-        return SERVICE(); 
+        return REGISTRY(); 
     }
 
     // from Versionable
@@ -196,32 +196,25 @@ contract RegistryService is
 
         // registerInstance() have no restriction
         config[0].serviceDomain = INSTANCE();
-        config[0].selector = new bytes4[](1);
-        config[0].selector[0] = RegistryService.registerInstance.selector;
+        config[0].selector = RegistryService.registerInstance.selector;
 
         config[1].serviceDomain = POOL();
-        config[1].selector = new bytes4[](1);
-        config[1].selector[0] = RegistryService.registerPool.selector;
+        config[1].selector = RegistryService.registerPool.selector;
 
         config[2].serviceDomain = DISTRIBUTION();
-        config[2].selector = new bytes4[](1);
-        config[2].selector[0] = RegistryService.registerDistribution.selector;
+        config[2].selector = RegistryService.registerDistribution.selector;
 
         config[3].serviceDomain = PRODUCT();
-        config[3].selector = new bytes4[](1);
-        config[3].selector[0] = RegistryService.registerProduct.selector;
+        config[3].selector = RegistryService.registerProduct.selector;
 
         config[4].serviceDomain = POLICY();
-        config[4].selector = new bytes4[](1);
-        config[4].selector[0] = RegistryService.registerPolicy.selector;
+        config[4].selector = RegistryService.registerPolicy.selector;
 
         config[5].serviceDomain = BUNDLE();
-        config[5].selector = new bytes4[](1);
-        config[5].selector[0] = RegistryService.registerBundle.selector;
+        config[5].selector = RegistryService.registerBundle.selector;
 
         /*config[6].serviceDomain = STAKE();
-        config[6].selector = new bytes4[](1);
-        config[6].selector[0] = RegistryService.registerStake.selector;*/
+        config[6].selector = RegistryService.registerStake.selector;*/
 
         data = abi.encode(config);
     }

package/contracts/registry/RegistryServiceManager.sol

@@ -17,7 +17,7 @@ contract RegistryServiceManager is
 {
     bytes32 constant public ACCESS_MANAGER_CREATION_CODE_HASH = 0x0;
 
-    RegistryService private immutable _registryService; 
+    RegistryService private immutable _registryService;
 
     /// @dev initializes proxy manager with registry service implementation and deploys registry
     constructor(
@@ -25,6 +25,9 @@ contract RegistryServiceManager is
         address registry) // used by implementation 
         ProxyManager()
     {
+        require(initialAuthority > address(0), "RegistryServiceManager: initial authority is 0");
+        require(registry > address(0), "RegistryServiceManager: registry is 0");
+        
         // implementation's initializer func `data` argument
         bytes memory initializationData = abi.encode(
             initialAuthority,
@@ -35,7 +38,6 @@ contract RegistryServiceManager is
             initializationData);
 
         _registryService = RegistryService(address(versionable));
-
     }
 
     // from IRegisterable