@etherisc/gif-next 0.0.2-b7d6ed2-016 → 0.0.2-b7e6198-021

package/contracts/registry/RegistryAdmin.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {IAuthorization} from "../authorization/IAuthorization.sol";
-import {IComponent} from "../shared/IComponent.sol";
 import {IRegistry} from "./IRegistry.sol";
 import {IService} from "../shared/IService.sol";
 import {IStaking} from "../staking/IStaking.sol";
@@ -10,16 +9,10 @@ import {IStaking} from "../staking/IStaking.sol";
 import {AccessAdmin} from "../authorization/AccessAdmin.sol";
 import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
 import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
-import {ContractLib} from "../shared/ContractLib.sol";
-import {ObjectType, REGISTRY, STAKING, POOL, RELEASE} from "../type/ObjectType.sol";
-import {ReleaseRegistry} from "./ReleaseRegistry.sol";
-import {RoleId, RoleIdLib, ADMIN_ROLE, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE, PUBLIC_ROLE} from "../type/RoleId.sol";
-import {Staking} from "../staking/Staking.sol";
-import {Str, StrLib} from "../type/String.sol";
-import {StakingStore} from "../staking/StakingStore.sol";
-import {TokenHandler} from "../shared/TokenHandler.sol";
-import {TokenRegistry} from "./TokenRegistry.sol";
-import {VersionPart, VersionPartLib} from "../type/Version.sol";
+import {ObjectType, REGISTRY} from "../type/ObjectType.sol";
+import {RoleId, RoleIdLib, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE} from "../type/RoleId.sol";
+import {Str} from "../type/String.sol";
+import {VersionPart} from "../type/Version.sol";
 
 /*
     1) GIF_MANAGER_ROLE
@@ -44,22 +37,15 @@ contract RegistryAdmin is
     /// @dev gif core roles
     string public constant GIF_ADMIN_ROLE_NAME = "GifAdminRole";
     string public constant GIF_MANAGER_ROLE_NAME = "GifManagerRole";
-    string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistryRole";
-    string public constant STAKING_ROLE_NAME = "StakingRole";
-
-    /// @dev gif roles for external contracts
-    string public constant REGISTRY_SERVICE_ROLE_NAME = "RegistryServiceRole";
-    string public constant COMPONENT_SERVICE_ROLE_NAME = "ComponentServiceRole";
-    string public constant POOL_SERVICE_ROLE_NAME = "PoolServiceRole";
-    string public constant STAKING_SERVICE_ROLE_NAME = "StakingServiceRole";
 
     /// @dev gif core targets
     string public constant REGISTRY_ADMIN_TARGET_NAME = "RegistryAdmin";
     string public constant REGISTRY_TARGET_NAME = "Registry";
     string public constant RELEASE_REGISTRY_TARGET_NAME = "ReleaseRegistry";
     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";
     string public constant TOKEN_REGISTRY_TARGET_NAME = "TokenRegistry";
     string public constant TOKEN_HANDLER_TARGET_NAME = "TokenHandler";
 
@@ -70,6 +56,7 @@ contract RegistryAdmin is
     address private _releaseRegistry;
     address private _tokenRegistry;
     address private _staking;
+    address private _stakingTargetHandler;
     address private _stakingStore;
 
     constructor() {
@@ -82,6 +69,7 @@ contract RegistryAdmin is
     function completeSetup(
         address registry,
         address authorization,
+        VersionPart release,
         address gifAdmin, 
         address gifManager
     )
@@ -91,15 +79,14 @@ contract RegistryAdmin is
         onlyDeployer()
     {
         // checks
-        _checkRegistry(registry);
+        AccessAdminLib.checkRegistry(registry);
 
-        VersionPart release = VersionPartLib.toVersionPart(3);
         AccessManagerCloneable(
             authority()).completeSetup(
                 registry, 
                 release); 
 
-        _checkAuthorization(authorization, REGISTRY(), release, true);
+        _checkAuthorization(authorization, REGISTRY(), release, false, true);
 
         _registry = registry;
         _authorization = IAuthorization(authorization);
@@ -108,25 +95,25 @@ contract RegistryAdmin is
         _releaseRegistry = registryContract.getReleaseRegistryAddress();
         _tokenRegistry = registryContract.getTokenRegistryAddress();
         _staking = registryContract.getStakingAddress();
-        _stakingStore = address(
-            IStaking(_staking).getStakingStore());
+        _stakingTargetHandler = address(IStaking(_staking).getTargetHandler());
+        _stakingStore = address(IStaking(_staking).getStakingStore());
 
         // link nft ownability to registry
         _linkToNftOwnable(_registry);
 
-        _setupRegistry(_registry);
+        // setup registry core targets
+        _createCoreTargets(_authorization.getMainTargetName());
 
-        // setup authorization for registry and supporting contracts
+        // setup non-contract roles
         _createRoles(_authorization);
         _grantRoleToAccount(GIF_ADMIN_ROLE(), gifAdmin);
         _grantRoleToAccount(GIF_MANAGER_ROLE(), gifManager);
 
-        _createTargets(_authorization);
+        // authorize functions of registry and staking contracts
         _createTargetAuthorizations(_authorization);
     }
 
 
-
     function grantServiceRoleForAllVersions(
         IService service, 
         ObjectType domain
@@ -135,83 +122,54 @@ contract RegistryAdmin is
         restricted()
     {
         _grantRoleToAccount( 
-            RoleIdLib.roleForTypeAndAllVersions(domain),
+            RoleIdLib.toGenericServiceRoleId(domain),
             address(service)); 
     }
 
     //--- view functions ----------------------------------------------------//
 
-    function getGifAdminRole() external view returns (RoleId) {
+    function getGifAdminRole() external pure returns (RoleId) {
         return GIF_ADMIN_ROLE();
     }
 
-    function getGifManagerRole() external view returns (RoleId) {
+    function getGifManagerRole() external pure returns (RoleId) {
         return GIF_MANAGER_ROLE();
     }
 
     //--- private initialization functions -------------------------------------------//
 
-    // create registry role and target
-    function _setupRegistry(address registry) internal {
-
-        // create registry role
-        RoleId roleId = _authorization.getTargetRole(
-            _authorization.getMainTarget());
-
-        _createRole(
-            roleId,
-            _authorization.getRoleInfo(roleId));
-
-        // create registry target
-        _createTarget(
-            registry, 
-            _authorization.getMainTargetName(), 
-            true, // checkAuthority
-            false); // custom
-
-        // assign registry role to registry
-        _grantRoleToAccount(
-            roleId, 
-            registry);
-    }
-
-
     function _createRoles(IAuthorization authorization)
         internal
     {
         RoleId[] memory roles = authorization.getRoles();
-        RoleId mainTargetRoleId = authorization.getTargetRole(
-            authorization.getMainTarget());
-
-        RoleId roleId;
-        RoleInfo memory roleInfo;
 
         for(uint256 i = 0; i < roles.length; i++) {
+            RoleId roleId = roles[i];
+            RoleInfo memory roleInfo = authorization.getRoleInfo(roleId);
 
-            roleId = roles[i];
-
-            // skip main target role, create role if not exists
-            if (roleId != mainTargetRoleId && !roleExists(roleId)) {
+            // create role if not exists
+            if (!roleExists(roleInfo.name.toString())) {
                 _createRole(
                     roleId,
-                    authorization.getRoleInfo(roleId));
+                    roleInfo);
             }
         }
     }
 
 
-    function _createTargets(IAuthorization authorization)
+    function _createCoreTargets(string memory registryTargetName)
         internal
     {
         // registry
-        _createTargetWithRole(address(this), REGISTRY_ADMIN_TARGET_NAME, authorization.getTargetRole(StrLib.toStr(REGISTRY_ADMIN_TARGET_NAME)));
-        _createTargetWithRole(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, authorization.getTargetRole(StrLib.toStr(RELEASE_REGISTRY_TARGET_NAME)));
-        _createTargetWithRole(_tokenRegistry, TOKEN_REGISTRY_TARGET_NAME, authorization.getTargetRole(StrLib.toStr(TOKEN_REGISTRY_TARGET_NAME)));
+        _createUncheckedTarget(_registry, registryTargetName, TargetType.Core);
+        _createUncheckedTarget(address(this), REGISTRY_ADMIN_TARGET_NAME, TargetType.Core);
+        _createUncheckedTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, TargetType.Core);
+        _createUncheckedTarget(_tokenRegistry, TOKEN_REGISTRY_TARGET_NAME, TargetType.Core);
 
         // staking
-        _createTargetWithRole(_staking, STAKING_TARGET_NAME, authorization.getTargetRole(StrLib.toStr(STAKING_TARGET_NAME)));
-        _createTarget(_stakingStore, STAKING_STORE_TARGET_NAME, true, false);
-        _createTarget(address(IComponent(_staking).getTokenHandler()), STAKING_TH_TARGET_NAME, true, false);
+        _createUncheckedTarget(_staking, STAKING_TARGET_NAME, TargetType.Core);
+        _createUncheckedTarget(_stakingTargetHandler, STAKING_TARGET_HANDLER_NAME, TargetType.Core);
+        _createUncheckedTarget(_stakingStore, STAKING_STORE_TARGET_NAME, TargetType.Core);
     }
 
 
@@ -224,35 +182,10 @@ contract RegistryAdmin is
         for(uint256 i = 0; i < targets.length; i++) {
             target = targets[i];
             RoleId[] memory authorizedRoles = authorization.getAuthorizedRoles(target);
-            RoleId authorizedRole;
 
             for(uint256 j = 0; j < authorizedRoles.length; j++) {
-                authorizedRole = authorizedRoles[j];
-
-                _authorizeTargetFunctions(
-                    getTargetForName(target),
-                    authorizedRole,
-                    authorization.getAuthorizedFunctions(
-                        target, 
-                        authorizedRole));
+                _authorizeFunctions(authorization, target, authorizedRoles[j]);
             }
         }
     }
-
-
-    function _createTargets(address authorization)
-        private 
-        onlyInitializing()
-    {
-        IStaking staking = IStaking(_staking);
-        address tokenHandler = address(staking.getTokenHandler());
-
-        _createTarget(address(this), REGISTRY_ADMIN_TARGET_NAME, false, false);
-        _createTarget(_registry, REGISTRY_TARGET_NAME, true, false);
-        _createTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, true, false);
-        _createTarget(_staking, STAKING_TARGET_NAME, true, false);
-        _createTarget(_stakingStore, STAKING_STORE_TARGET_NAME, true, false);
-        _createTarget(_tokenRegistry, TOKEN_REGISTRY_TARGET_NAME, true, false);
-        _createTarget(tokenHandler, TOKEN_HANDLER_TARGET_NAME, true, false);
-    }
 }

package/contracts/registry/RegistryAuthorization.sol

@@ -6,20 +6,21 @@ import {IRegistry} from "../registry/IRegistry.sol";
 import {IStaking} from "../staking/IStaking.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,39 +40,57 @@ 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, 
+               false, // isComponent
+               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()), 
+               RoleIdLib.toGenericServiceRoleId(REGISTRY()), 
                _toRoleInfo({
                     adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
                     name: REGISTRY_SERVICE_ROLE_NAME}));
 
           _addRole(
-               RoleIdLib.roleForTypeAndAllVersions(STAKING()), 
+               RoleIdLib.toGenericServiceRoleId(STAKING()), 
                _toRoleInfo({
                     adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
                     name: STAKING_SERVICE_ROLE_NAME}));
 
           _addRole(
-               RoleIdLib.roleForTypeAndAllVersions(POOL()), 
+               RoleIdLib.toGenericServiceRoleId(COMPONENT()), 
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
+                    name: COMPONENT_SERVICE_ROLE_NAME}));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(POOL()), 
                _toRoleInfo({
                     adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
-                    maxMemberCount: 999, // max member count = max 
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
                     name: POOL_SERVICE_ROLE_NAME}));
 
           // gif admin role
@@ -79,7 +98,7 @@ contract RegistryAuthorization
                GIF_ADMIN_ROLE(),
                _toRoleInfo({
                     adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
+                    roleType: RoleType.Core,
                     maxMemberCount: 2, // TODO decide on max member count
                     name: GIF_ADMIN_ROLE_NAME}));
 
@@ -88,7 +107,7 @@ contract RegistryAuthorization
                GIF_MANAGER_ROLE(), 
                _toRoleInfo({
                     adminRoleId: ADMIN_ROLE(),
-                    roleType: RoleType.Gif,
+                    roleType: RoleType.Core,
                     maxMemberCount: 1, // TODO decide on max member count
                     name: GIF_MANAGER_ROLE_NAME}));
 
@@ -96,13 +115,14 @@ contract RegistryAuthorization
 
      /// @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 +138,9 @@ contract RegistryAuthorization
 
           // staking
           _setupStakingAuthorization();
-          _setupStakingThAuthorization();
+          _setupStakingTargetHandlerAuthorization();
           _setupStakingStoreAuthorization();
+          _setupStakingThAuthorization();
      }
 
      event LogAccessAdminDebug(string message, string custom, uint256 value);
@@ -134,7 +155,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 +212,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.toGenericServiceRoleId(COMPONENT()));
+
+          _authorize(functions, IStaking.addTargetToken.selector, "addTargetToken");
 
           // pool service role
           functions = _authorizeForTarget(
                STAKING_TARGET_NAME, 
-               RoleIdLib.roleForTypeAndAllVersions(POOL()));
+               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 +295,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,