@etherisc/gif-next 0.0.2-ffa91a6-022 → 3.0.0-0fefe0d-162

package/contracts/registry/RegistryAuthorization.sol

@@ -5,21 +5,23 @@ import {IAccess} from "../authorization/IAccess.sol";
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "../staking/IStaking.sol";
 
+import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
 import {Authorization} from "../authorization/Authorization.sol";
-import {POOL, REGISTRY, STAKING} from "../../contracts/type/ObjectType.sol";
+import {COMPONENT, POOL, REGISTRY, STAKING} from "../../contracts/type/ObjectType.sol";
 import {PUBLIC_ROLE} from "../type/RoleId.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 import {RoleIdLib, ADMIN_ROLE, GIF_ADMIN_ROLE, GIF_MANAGER_ROLE} from "../type/RoleId.sol";
 import {StakingStore} from "../staking/StakingStore.sol";
+import {TargetHandler} from "../staking/TargetHandler.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenRegistry} from "../registry/TokenRegistry.sol";
+import {VersionPartLib} from "../type/Version.sol";
 
 
 contract RegistryAuthorization
      is Authorization
 {
-
      /// @dev gif core roles
      string public constant GIF_ADMIN_ROLE_NAME = "GifAdminRole";
      string public constant GIF_MANAGER_ROLE_NAME = "GifManagerRole";
@@ -39,70 +41,89 @@ contract RegistryAuthorization
      string public constant TOKEN_REGISTRY_TARGET_NAME = "TokenRegistry";
 
      string public constant STAKING_TARGET_NAME = "Staking";
-     string public constant STAKING_TH_TARGET_NAME = "StakingTH";
+     string public constant STAKING_TARGET_HANDLER_NAME = "TargetHandler";
      string public constant STAKING_STORE_TARGET_NAME = "StakingStore";
+     string public constant STAKING_TH_TARGET_NAME = "StakingTh";
 
-     constructor()
-          Authorization(REGISTRY_TARGET_NAME, REGISTRY(), false, false)
+     constructor(string memory commitHash)
+          Authorization(
+               REGISTRY_TARGET_NAME, 
+               REGISTRY(), 
+               3, 
+               commitHash, 
+               TargetType.Core,
+               false) // includeTokenHandler
      { }
 
      /// @dev Sets up the GIF admin and manager roles.
      function _setupRoles() internal override {
 
-          // service roles (for all versions)
+          // max number of versioned contracts per generic service
+          uint32 maxReleases = uint32(VersionPartLib.releaseMax().toInt());
+
+          // service roles (for all releases)
           _addRole(
-               RoleIdLib.roleForTypeAndAllVersions(REGISTRY()), 
-               _toRoleInfo({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
-                    name: REGISTRY_SERVICE_ROLE_NAME}));
+               RoleIdLib.toGenericServiceRoleId(REGISTRY()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    REGISTRY_SERVICE_ROLE_NAME));
 
           _addRole(
-               RoleIdLib.roleForTypeAndAllVersions(STAKING()), 
-               _toRoleInfo({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
-                    name: STAKING_SERVICE_ROLE_NAME}));
+               RoleIdLib.toGenericServiceRoleId(STAKING()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    STAKING_SERVICE_ROLE_NAME));
 
           _addRole(
-               RoleIdLib.roleForTypeAndAllVersions(POOL()), 
-               _toRoleInfo({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
-                    name: POOL_SERVICE_ROLE_NAME}));
+               RoleIdLib.toGenericServiceRoleId(COMPONENT()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    COMPONENT_SERVICE_ROLE_NAME));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(POOL()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    POOL_SERVICE_ROLE_NAME));
 
           // gif admin role
           _addRole(
                GIF_ADMIN_ROLE(),
-               _toRoleInfo({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 2, // TODO decide on max member count
-                    name: GIF_ADMIN_ROLE_NAME}));
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Custom, // custom is only type that allows role removal
+                    2, // TODO decide on max member count
+                    GIF_ADMIN_ROLE_NAME));
 
           // gif manager role
           _addRole(
                GIF_MANAGER_ROLE(), 
-               _toRoleInfo({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 1, // TODO decide on max member count
-                    name: GIF_MANAGER_ROLE_NAME}));
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Custom, // custom is only type that allows role removal
+                    1, // TODO decide on max member count
+                    GIF_MANAGER_ROLE_NAME));
 
      }
 
      /// @dev Sets up the relevant (non-service) targets for the registry.
      function _setupTargets() internal override {
-          _addGifContractTarget(REGISTRY_ADMIN_TARGET_NAME);
-          _addGifContractTarget(RELEASE_REGISTRY_TARGET_NAME);
-          _addGifContractTarget(TOKEN_REGISTRY_TARGET_NAME);
-
-          _addGifContractTarget(STAKING_TARGET_NAME);
-          _addGifContractTarget(STAKING_TH_TARGET_NAME);
-          _addTarget(STAKING_STORE_TARGET_NAME);
+          _addGifTarget(REGISTRY_ADMIN_TARGET_NAME);
+          _addGifTarget(RELEASE_REGISTRY_TARGET_NAME);
+          _addGifTarget(TOKEN_REGISTRY_TARGET_NAME);
+
+          _addGifTarget(STAKING_TARGET_NAME);
+          _addGifTarget(STAKING_TARGET_HANDLER_NAME);
+          _addGifTarget(STAKING_STORE_TARGET_NAME);
+          _addGifTarget(STAKING_TH_TARGET_NAME);
      }
 
 
@@ -118,8 +139,9 @@ contract RegistryAuthorization
 
           // staking
           _setupStakingAuthorization();
-          _setupStakingThAuthorization();
+          _setupStakingTargetHandlerAuthorization();
           _setupStakingStoreAuthorization();
+          _setupStakingThAuthorization();
      }
 
      event LogAccessAdminDebug(string message, string custom, uint256 value);
@@ -134,7 +156,7 @@ contract RegistryAuthorization
           // registry service role
           functions = _authorizeForTarget(
                REGISTRY_TARGET_NAME, 
-               RoleIdLib.roleForTypeAndAllVersions(REGISTRY()));
+               RoleIdLib.toGenericServiceRoleId(REGISTRY()));
 
           _authorize(functions, IRegistry.register.selector, "register");
           _authorize(functions, IRegistry.registerWithCustomType.selector, "registerWithCustomType");
@@ -191,52 +213,78 @@ contract RegistryAuthorization
      function _setupStakingAuthorization() internal {
           IAccess.FunctionInfo[] storage functions;
 
-          // staking public role
+          // staking public role (protected by owner)
           functions = _authorizeForTarget(
                STAKING_TARGET_NAME,
                PUBLIC_ROLE());
 
+          // unpermissioned functions
+          _authorize(functions, IStaking.updateTargetLimit.selector, "updateTargetLimit");
+          _authorize(functions, IStaking.createStake.selector, "createStake");
+
+          // owner functions (permissioned to staking owner)
+          _authorize(functions, IStaking.setSupportInfo.selector, "setSupportInfo");
+          _authorize(functions, IStaking.setUpdateTriggers.selector, "setUpdateTriggers");
+          _authorize(functions, IStaking.setProtocolLockingPeriod.selector, "setProtocolLockingPeriod");
+          _authorize(functions, IStaking.setProtocolRewardRate.selector, "setProtocolRewardRate");
+          _authorize(functions, IStaking.setStakingRate.selector, "setStakingRate");
+          _authorize(functions, IStaking.setStakingService.selector, "setStakingService");
+          _authorize(functions, IStaking.setStakingReader.selector, "setStakingReader");
+          _authorize(functions, IStaking.addToken.selector, "addToken");
+          
+          // target owner functions (permissioned to target owner)
+          _authorize(functions, IStaking.setTargetLimits.selector, "setTargetLimits");
+
+          // staker functions (may be permissioned to nft holders)
+          _authorize(functions, IStaking.stake.selector, "stake");
+          _authorize(functions, IStaking.unstake.selector, "unstake");
+          _authorize(functions, IStaking.restake.selector, "restake");
+          _authorize(functions, IStaking.updateRewards.selector, "updateRewards");
+          _authorize(functions, IStaking.claimRewards.selector, "claimRewards");
+
+          // reward reserve functions and token handler
           _authorize(functions, IStaking.approveTokenHandler.selector, "approveTokenHandler");
+          _authorize(functions, IStaking.refillRewardReserves.selector, "refillRewardReserves");
+          _authorize(functions, IStaking.withdrawRewardReserves.selector, "withdrawRewardReserves");
 
           // staking service role
           functions = _authorizeForTarget(
                STAKING_TARGET_NAME, 
-               RoleIdLib.roleForTypeAndAllVersions(STAKING()));
+               RoleIdLib.toGenericServiceRoleId(STAKING()));
 
           _authorize(functions, IStaking.registerTarget.selector, "registerTarget");
           _authorize(functions, IStaking.setLockingPeriod.selector, "setLockingPeriod");
           _authorize(functions, IStaking.setRewardRate.selector, "setRewardRate");
           _authorize(functions, IStaking.setMaxStakedAmount.selector, "setMaxStakedAmount");
-          _authorize(functions, IStaking.refillRewardReserves.selector, "refillRewardReserves");
-          _authorize(functions, IStaking.withdrawRewardReserves.selector, "withdrawRewardReserves");
-          _authorize(functions, IStaking.createStake.selector, "createStake");
-          _authorize(functions, IStaking.stake.selector, "stake");
-          _authorize(functions, IStaking.unstake.selector, "unstake");
-          _authorize(functions, IStaking.restake.selector, "restake");
-          _authorize(functions, IStaking.updateRewards.selector, "updateRewards");
-          _authorize(functions, IStaking.claimRewards.selector, "claimRewards");
+          _authorize(functions, IStaking.refillRewardReservesByService.selector, "refillRewardReservesByService");
+          _authorize(functions, IStaking.withdrawRewardReservesByService.selector, "withdrawRewardReservesByService");
 
           // pool service role
           functions = _authorizeForTarget(
                STAKING_TARGET_NAME, 
-               RoleIdLib.roleForTypeAndAllVersions(POOL()));
+               RoleIdLib.toGenericServiceRoleId(COMPONENT()));
+
+          _authorize(functions, IStaking.addTargetToken.selector, "addTargetToken");
+
+          // pool service role
+          functions = _authorizeForTarget(
+               STAKING_TARGET_NAME, 
+               RoleIdLib.toGenericServiceRoleId(POOL()));
 
           _authorize(functions, IStaking.increaseTotalValueLocked.selector, "increaseTotalValueLocked");
           _authorize(functions, IStaking.decreaseTotalValueLocked.selector, "decreaseTotalValueLocked");
      }
 
 
-     function _setupStakingThAuthorization() internal {
+     function _setupStakingTargetHandlerAuthorization() internal {
           IAccess.FunctionInfo[] storage functions;
 
           // staking service role
           functions = _authorizeForTarget(
-               STAKING_TH_TARGET_NAME,
-               RoleIdLib.roleForTypeAndAllVersions(STAKING()));
+               STAKING_TARGET_HANDLER_NAME,
+               getTargetRole(getTarget(STAKING_TARGET_NAME)));
 
-          _authorize(functions, TokenHandler.approve.selector, "approve");
-          _authorize(functions, TokenHandler.pullToken.selector, "pullToken");
-          _authorize(functions, TokenHandler.pushToken.selector, "pushToken");
+          _authorize(functions, TargetHandler.setUpdateTriggers.selector, "setUpdateTriggers");
      }
 
 
@@ -248,20 +296,42 @@ contract RegistryAuthorization
                STAKING_STORE_TARGET_NAME, 
                getTargetRole(getTarget(STAKING_TARGET_NAME)));
 
+          _authorize(functions, StakingStore.setTargetLimits.selector, "setTargetLimits");
+          _authorize(functions, StakingStore.updateTargetLimit.selector, "updateTargetLimit");
+          _authorize(functions, StakingStore.setStakingReader.selector, "setStakingReader");
+          _authorize(functions, StakingStore.setTargetLimitHandler.selector, "setTargetLimitHandler");
+          _authorize(functions, StakingStore.setSupportInfo.selector, "setSupportInfo");
+          _authorize(functions, StakingStore.addToken.selector, "addToken");
+          _authorize(functions, StakingStore.addTargetToken.selector, "addTargetToken");
           _authorize(functions, StakingStore.setStakingRate.selector, "setStakingRate");
           _authorize(functions, StakingStore.createTarget.selector, "createTarget");
-          _authorize(functions, StakingStore.updateTarget.selector, "updateTarget");
-          _authorize(functions, StakingStore.increaseReserves.selector, "increaseReserves");
-          _authorize(functions, StakingStore.decreaseReserves.selector, "decreaseReserves");
+          _authorize(functions, StakingStore.setLockingPeriod.selector, "setLockingPeriod");
+          _authorize(functions, StakingStore.setRewardRate.selector, "setRewardRate");
+          _authorize(functions, StakingStore.setMaxStakedAmount.selector, "setMaxStakedAmount");
+          _authorize(functions, StakingStore.refillRewardReserves.selector, "refillRewardReserves");
+          _authorize(functions, StakingStore.withdrawRewardReserves.selector, "withdrawRewardReserves");
           _authorize(functions, StakingStore.increaseTotalValueLocked.selector, "increaseTotalValueLocked");
           _authorize(functions, StakingStore.decreaseTotalValueLocked.selector, "decreaseTotalValueLocked");
-          _authorize(functions, StakingStore.create.selector, "create");
-          _authorize(functions, StakingStore.update.selector, "update");
-          _authorize(functions, StakingStore.increaseStake.selector, "increaseStake");
-          _authorize(functions, StakingStore.restakeRewards.selector, "restakeRewards");
+          _authorize(functions, StakingStore.createStake.selector, "createStake");
+          _authorize(functions, StakingStore.stake.selector, "stake");
+          _authorize(functions, StakingStore.unstake.selector, "unstake");
           _authorize(functions, StakingStore.updateRewards.selector, "updateRewards");
-          _authorize(functions, StakingStore.claimUpTo.selector, "claimUpTo");
-          _authorize(functions, StakingStore.unstakeUpTo.selector, "unstakeUpTo");
+          _authorize(functions, StakingStore.restakeRewards.selector, "restakeRewards");
+          _authorize(functions, StakingStore.claimRewards.selector, "claimRewards");
+     }
+
+
+     function _setupStakingThAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // staking service role
+          functions = _authorizeForTarget(
+               STAKING_TH_TARGET_NAME,
+               RoleIdLib.toGenericServiceRoleId(STAKING()));
+
+          _authorize(functions, TokenHandler.approve.selector, "approve");
+          _authorize(functions, TokenHandler.pullToken.selector, "pullToken");
+          _authorize(functions, TokenHandler.pushToken.selector, "pushToken");
      }
 }
 

package/contracts/registry/RegistryService.sol

@@ -30,7 +30,7 @@ contract RegistryService is
     )
         internal
         virtual override
-        initializer()
+        onlyInitializing
     {
         (
             address authority,

package/contracts/registry/ReleaseAdmin.sol

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessAdmin} from "../authorization/AccessAdmin.sol";
-import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
-import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
 import {IAccess} from "../authorization/IAccess.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
 import {IService} from "../shared/IService.sol";
 import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
-import {ObjectType, ObjectTypeLib, ALL} from "../type/ObjectType.sol";
-import {RoleId, RoleIdLib, ADMIN_ROLE, RELEASE_REGISTRY_ROLE, PUBLIC_ROLE} from "../type/RoleId.sol";
+
+import {AccessAdmin} from "../authorization/AccessAdmin.sol";
+import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
+import {ObjectType, ObjectTypeLib, RELEASE} from "../type/ObjectType.sol";
+import {RoleId, ADMIN_ROLE, RELEASE_REGISTRY_ROLE} from "../type/RoleId.sol";
+import {Str} from "../type/String.sol";
 import {VersionPart} from "../type/Version.sol";
 
+
 /// @dev The ReleaseAdmin contract implements the central authorization for the services of a specific release.
 /// There is one ReleaseAdmin contract per major GIF release.
 /// Locking/unlocking of all services of a release is implemented in function setReleaseLocked.
@@ -25,11 +29,13 @@ contract ReleaseAdmin is
     error ErrorReleaseAdminReleaseLockAlreadySetTo(bool locked);
 
     /// @dev release core roles
-    string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistryRole";
+    string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistry_Role";
 
     /// @dev release core targets
     string public constant RELEASE_ADMIN_TARGET_NAME = "ReleaseAdmin";
 
+    IServiceAuthorization internal _serviceAuthorization;
+
 
     modifier onlyReleaseRegistry() {
         (bool isMember, ) = _authority.hasRole(RELEASE_REGISTRY_ROLE().toInt(), msg.sender);
@@ -39,6 +45,7 @@ contract ReleaseAdmin is
         _;
     }
 
+
     // @dev Only used for master release admin
     constructor(address accessManager) {
         initialize(
@@ -49,32 +56,41 @@ contract ReleaseAdmin is
 
     function completeSetup(
         address registry,
-        address releaseRegistry,
-        VersionPart release
+        address authorization,
+        VersionPart release,
+        address releaseRegistry
     )
         external
         reinitializer(uint64(release.toInt()))
     {
-
         // checks
-        _checkRegistry(registry);
+        AccessAdminLib.checkRegistry(registry);
 
         AccessManagerCloneable(
             authority()).completeSetup(
                 registry, 
-                release); 
+                release);
+
+        IServiceAuthorization serviceAuthorization = IServiceAuthorization(authorization);
+        _checkAuthorization(address(serviceAuthorization), RELEASE(), release, true, true);
+        _serviceAuthorization = serviceAuthorization;
 
         // link nft ownability to registry
         _linkToNftOwnable(registry);
 
+        _createRoles(_serviceAuthorization);
+
+        // setup release contract
         _setupReleaseRegistry(releaseRegistry);
+
+        // relase services will be authorized one by one via authorizeService()
     }
 
+
     /// @dev Sets up authorizaion for specified service.
     /// For all authorized services its authorized functions are enabled.
     /// Permissioned function: Access is restricted to release registry.
     function authorizeService(
-        IServiceAuthorization serviceAuthorization,
         IService service,
         ObjectType serviceDomain,
         VersionPart release
@@ -83,9 +99,20 @@ contract ReleaseAdmin is
         restricted()
     {
         _createServiceTargetAndRole(service, serviceDomain, release);
-        _authorizeServiceFunctions(serviceAuthorization, service, serviceDomain, release);
+
+        // authorize functions of service
+        Str serviceTarget = _serviceAuthorization.getServiceTarget(serviceDomain);
+        RoleId[] memory authorizedRoles = _serviceAuthorization.getAuthorizedRoles(serviceTarget);
+
+        for (uint256 i = 0; i < authorizedRoles.length; i++) {
+            _authorizeFunctions(
+                IAuthorization(address(_serviceAuthorization)), 
+                serviceTarget, 
+                authorizedRoles[i]);
+        }
     }
 
+
     /// @dev Locks/unlocks all release targets.
     /// For all authorized services of release its authorized functions are disabled/enabled.
     /// Permissioned function: Access is restricted to release registry.
@@ -106,6 +133,7 @@ contract ReleaseAdmin is
         emit LogReleaseAdminReleaseLockChanged(getRelease(), locked);
     }
 
+
     /// @dev Lock/unlock specific service of release.
     /// Permissioned function: Access is restricted to release registry.
     function setServiceLocked(IService service, bool locked)
@@ -123,13 +151,6 @@ contract ReleaseAdmin is
         emit LogReleaseAdminServiceLockChanged(service.getRelease(), address(service), locked);
     }
 
-    //--- view functions ----------------------------------------------------//
-
-/*
-    function getReleaseAdminRole() external view returns (RoleId) {
-        return GIF_ADMIN_ROLE();
-    }
-*/
     //--- private functions -------------------------------------------------//
 
     function _createServiceTargetAndRole(
@@ -145,85 +166,8 @@ contract ReleaseAdmin is
         string memory serviceTargetName = ObjectTypeLib.toVersionedName(
             baseName, "Service", release);
 
-        _createTarget(
-            address(service), 
-            serviceTargetName,
-            true,
-            false);
-
-        // create service role
-        RoleId serviceRoleId = RoleIdLib.roleForTypeAndVersion(
-            serviceDomain, 
-            release);
-
-        if(!roleExists(serviceRoleId)) {
-            _createRole(
-                serviceRoleId, 
-                AccessAdminLib.toRole({
-                    adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Contract,
-                    maxMemberCount: 1,
-                    name: ObjectTypeLib.toVersionedName(
-                        baseName, 
-                        "ServiceRole", 
-                        release)}));
-        }
-
-        _grantRoleToAccount( 
-            serviceRoleId,
-            address(service)); 
-    }
-
-
-    function _authorizeServiceFunctions(
-        IServiceAuthorization serviceAuthorization,
-        IService service,
-        ObjectType serviceDomain, 
-        VersionPart release
-    )
-        private
-    {
-        ObjectType authorizedDomain;
-        RoleId authorizedRoleId;
-
-        ObjectType[] memory authorizedDomains = serviceAuthorization.getAuthorizedDomains(serviceDomain);
-
-        for (uint256 i = 0; i < authorizedDomains.length; i++) {
-            authorizedDomain = authorizedDomains[i];
-
-            // derive authorized role from authorized domain
-            if (authorizedDomain == ALL()) {
-                authorizedRoleId = PUBLIC_ROLE();
-            } else {
-                authorizedRoleId = RoleIdLib.roleForTypeAndVersion(
-                authorizedDomain, 
-                release);
-            }
-
-            if(!roleExists(authorizedRoleId)) {
-                // create role for authorized domain
-                _createRole(
-                    authorizedRoleId, 
-                    AccessAdminLib.toRole({
-                        adminRoleId: ADMIN_ROLE(),
-                        roleType: RoleType.Contract,
-                        maxMemberCount: 1,
-                        name: ObjectTypeLib.toVersionedName(
-                            ObjectTypeLib.toName(authorizedDomain), 
-                            "Role", 
-                            release)}));
-            }
-
-            // get authorized functions for authorized domain
-            IAccess.FunctionInfo[] memory authorizatedFunctions = serviceAuthorization.getAuthorizedFunctions(
-                serviceDomain, 
-                authorizedDomain);
-
-            _authorizeTargetFunctions(
-                    address(service), 
-                    authorizedRoleId, 
-                    authorizatedFunctions);
-        }
+        // create unchecked target
+        _createTarget(address(service), serviceTargetName, TargetType.Service, false);
     }
 
     //--- private initialization functions -------------------------------------------//
@@ -232,21 +176,23 @@ contract ReleaseAdmin is
         private 
         onlyInitializing()
     {
-        _createTarget(address(this), RELEASE_ADMIN_TARGET_NAME, false, false);
 
         _createRole(
             RELEASE_REGISTRY_ROLE(), 
-            AccessAdminLib.toRole({
-                adminRoleId: ADMIN_ROLE(),
-                roleType: RoleType.Contract,
-                maxMemberCount: 1,
-                name: RELEASE_REGISTRY_ROLE_NAME}));
+            AccessAdminLib.coreRoleInfo(RELEASE_REGISTRY_ROLE_NAME),
+            true); // revets on existing role
+
+        _createTarget(
+            address(this), 
+            RELEASE_ADMIN_TARGET_NAME,
+            IAccess.TargetType.Core, 
+            true); // check authority maches
 
         FunctionInfo[] memory functions;
         functions = new FunctionInfo[](2);
         functions[0] = AccessAdminLib.toFunction(ReleaseAdmin.authorizeService.selector, "authorizeService");
         functions[1] = AccessAdminLib.toFunction(ReleaseAdmin.setServiceLocked.selector, "setServiceLocked");
-        _authorizeTargetFunctions(address(this), RELEASE_REGISTRY_ROLE(), functions);
+        _authorizeTargetFunctions(address(this), RELEASE_REGISTRY_ROLE(), functions, false, true);
 
         _grantRoleToAccount(RELEASE_REGISTRY_ROLE(), releaseRegistry);
     }