@etherisc/gif-next 0.0.2-f15b559-661 → 0.0.2-f1b01e0-214

package/contracts/registry/RegistryAuthorization.sol

@@ -0,0 +1,267 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../authorization/IAccess.sol";
+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 {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 {TokenHandler} from "../shared/TokenHandler.sol";
+import {TokenRegistry} from "../registry/TokenRegistry.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";
+     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 TOKEN_REGISTRY_TARGET_NAME = "TokenRegistry";
+
+     string public constant STAKING_TARGET_NAME = "Staking";
+     string public constant STAKING_TH_TARGET_NAME = "StakingTH";
+     string public constant STAKING_STORE_TARGET_NAME = "StakingStore";
+
+     constructor()
+          Authorization(REGISTRY_TARGET_NAME, REGISTRY(), false, false)
+     { }
+
+     /// @dev Sets up the GIF admin and manager roles.
+     function _setupRoles() internal override {
+
+          // service roles (for all versions)
+          _addRole(
+               RoleIdLib.roleForTypeAndAllVersions(REGISTRY()), 
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Gif,
+                    maxMemberCount: 999, // max member count = max 
+                    name: 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}));
+
+          _addRole(
+               RoleIdLib.roleForTypeAndAllVersions(POOL()), 
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Gif,
+                    maxMemberCount: 999, // max member count = max 
+                    name: 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}));
+
+          // 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}));
+
+     }
+
+     /// @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);
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          override
+     {
+          // registry
+          _setupRegistryAuthorization();
+          _setupRegistryAdminAuthorization();
+          _setupReleaseRegistryAuthorization();
+          _setupTokenRegistryAuthorization();
+
+          // staking
+          _setupStakingAuthorization();
+          _setupStakingThAuthorization();
+          _setupStakingStoreAuthorization();
+     }
+
+     event LogAccessAdminDebug(string message, string custom, uint256 value);
+
+     function _setupRegistryAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // gif admin role
+          functions = _authorizeForTarget(REGISTRY_TARGET_NAME, GIF_ADMIN_ROLE());
+          _authorize(functions, IRegistry.registerRegistry.selector, "registerRegistry");
+
+          // registry service role
+          functions = _authorizeForTarget(
+               REGISTRY_TARGET_NAME, 
+               RoleIdLib.roleForTypeAndAllVersions(REGISTRY()));
+
+          _authorize(functions, IRegistry.register.selector, "register");
+          _authorize(functions, IRegistry.registerWithCustomType.selector, "registerWithCustomType");
+          
+          // release registry role
+          functions = _authorizeForTarget(
+               REGISTRY_TARGET_NAME, 
+               getTargetRole(getTarget(RELEASE_REGISTRY_TARGET_NAME)));
+
+          _authorize(functions, IRegistry.registerService.selector, "registerService");
+     }
+
+
+     function _setupRegistryAdminAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // release registry role
+          functions = _authorizeForTarget(
+               REGISTRY_ADMIN_TARGET_NAME, 
+               getTargetRole(getTarget(RELEASE_REGISTRY_TARGET_NAME)));
+
+          _authorize(functions, RegistryAdmin.grantServiceRoleForAllVersions.selector, "grantServiceRoleForAllVersions");
+     }
+
+
+     function _setupReleaseRegistryAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          functions = _authorizeForTarget(RELEASE_REGISTRY_TARGET_NAME, GIF_ADMIN_ROLE());
+          _authorize(functions, ReleaseRegistry.createNextRelease.selector, "createNextRelease");
+          _authorize(functions, ReleaseRegistry.activateNextRelease.selector, "activateNextRelease");
+          _authorize(functions, ReleaseRegistry.setActive.selector, "setActive");
+
+          functions = _authorizeForTarget(RELEASE_REGISTRY_TARGET_NAME, GIF_MANAGER_ROLE());
+          _authorize(functions, ReleaseRegistry.prepareNextRelease.selector, "prepareNextRelease");
+          _authorize(functions, ReleaseRegistry.registerService.selector, "registerService");
+     }
+
+
+     function _setupTokenRegistryAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // gif manager role
+          functions = _authorizeForTarget(TOKEN_REGISTRY_TARGET_NAME, GIF_MANAGER_ROLE());
+          _authorize(functions, TokenRegistry.registerToken.selector, "registerToken");
+          _authorize(functions, TokenRegistry.registerRemoteToken.selector, "registerRemoteToken");
+          _authorize(functions, TokenRegistry.setActive.selector, "setActive");
+          _authorize(functions, TokenRegistry.setActiveForVersion.selector, "setActiveForVersion");
+          // TODO find a better way (only needed for testing)
+          _authorize(functions, TokenRegistry.setActiveWithVersionCheck.selector, "setActiveWithVersionCheck");
+     }
+
+
+     function _setupStakingAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // staking public role
+          functions = _authorizeForTarget(
+               STAKING_TARGET_NAME,
+               PUBLIC_ROLE());
+
+          _authorize(functions, IStaking.approveTokenHandler.selector, "approveTokenHandler");
+
+          // staking service role
+          functions = _authorizeForTarget(
+               STAKING_TARGET_NAME, 
+               RoleIdLib.roleForTypeAndAllVersions(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");
+
+          // pool service role
+          functions = _authorizeForTarget(
+               STAKING_TARGET_NAME, 
+               RoleIdLib.roleForTypeAndAllVersions(POOL()));
+
+          _authorize(functions, IStaking.increaseTotalValueLocked.selector, "increaseTotalValueLocked");
+          _authorize(functions, IStaking.decreaseTotalValueLocked.selector, "decreaseTotalValueLocked");
+     }
+
+
+     function _setupStakingThAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // staking service role
+          functions = _authorizeForTarget(
+               STAKING_TH_TARGET_NAME,
+               RoleIdLib.roleForTypeAndAllVersions(STAKING()));
+
+          _authorize(functions, TokenHandler.approve.selector, "approve");
+          _authorize(functions, TokenHandler.pullToken.selector, "pullToken");
+          _authorize(functions, TokenHandler.pushToken.selector, "pushToken");
+     }
+
+
+     function _setupStakingStoreAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // release registry role
+          functions = _authorizeForTarget(
+               STAKING_STORE_TARGET_NAME, 
+               getTargetRole(getTarget(STAKING_TARGET_NAME)));
+
+          _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.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.updateRewards.selector, "updateRewards");
+          _authorize(functions, StakingStore.claimUpTo.selector, "claimUpTo");
+          _authorize(functions, StakingStore.unstakeUpTo.selector, "unstakeUpTo");
+     }
+}
+

package/contracts/registry/ReleaseAdmin.sol

@@ -2,6 +2,7 @@
 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 {IService} from "../shared/IService.sol";
@@ -38,13 +39,14 @@ contract ReleaseAdmin is
         _;
     }
 
-    /// @dev Only used for master release admin.
-    /// Contracts created via constructor come with disabled initializers.
-    constructor() {
-        initialize(new AccessManagerCloneable());
-        _disableInitializers();
+    // @dev Only used for master release admin
+    constructor(address accessManager) {
+        initialize(
+            accessManager,
+            "MasterReleaseAdmin");
     }
 
+
     function completeSetup(
         address registry,
         address releaseRegistry,
@@ -53,11 +55,18 @@ contract ReleaseAdmin is
         external
         reinitializer(uint64(release.toInt()))
     {
+
+        // checks
+        _checkRegistry(registry);
+
         AccessManagerCloneable(
             authority()).completeSetup(
                 registry, 
                 release); 
 
+        // link nft ownability to registry
+        _linkToNftOwnable(registry);
+
         _setupReleaseRegistry(releaseRegistry);
     }
 
@@ -68,13 +77,13 @@ contract ReleaseAdmin is
         IServiceAuthorization serviceAuthorization,
         IService service,
         ObjectType serviceDomain,
-        VersionPart releaseVersion
+        VersionPart release
     )
         external
         restricted()
     {
-        _createServiceTargetAndRole(service, serviceDomain, releaseVersion);
-        _authorizeServiceFunctions(serviceAuthorization, service, serviceDomain, releaseVersion);
+        _createServiceTargetAndRole(service, serviceDomain, release);
+        _authorizeServiceFunctions(serviceAuthorization, service, serviceDomain, release);
     }
 
     /// @dev Locks/unlocks all release targets.
@@ -109,7 +118,7 @@ contract ReleaseAdmin is
             revert ErrorReleaseAdminNotService(address(service));
         }
 
-        _setTargetClosed(address(service), locked);
+        _setTargetLocked(address(service), locked);
 
         emit LogReleaseAdminServiceLockChanged(service.getRelease(), address(service), locked);
     }
@@ -126,16 +135,15 @@ contract ReleaseAdmin is
     function _createServiceTargetAndRole(
         IService service, 
         ObjectType serviceDomain, 
-        VersionPart releaseVersion
+        VersionPart release
     )
         private
     {
         string memory baseName = ObjectTypeLib.toName(serviceDomain);
-        uint256 versionInt = releaseVersion.toInt();
 
         // create service target
         string memory serviceTargetName = ObjectTypeLib.toVersionedName(
-            baseName, "Service", versionInt);
+            baseName, "Service", release);
 
         _createTarget(
             address(service), 
@@ -146,19 +154,19 @@ contract ReleaseAdmin is
         // create service role
         RoleId serviceRoleId = RoleIdLib.roleForTypeAndVersion(
             serviceDomain, 
-            releaseVersion);
+            release);
 
         if(!roleExists(serviceRoleId)) {
             _createRole(
                 serviceRoleId, 
-                toRole({
+                AccessAdminLib.toRole({
                     adminRoleId: ADMIN_ROLE(),
                     roleType: RoleType.Contract,
                     maxMemberCount: 1,
                     name: ObjectTypeLib.toVersionedName(
                         baseName, 
                         "ServiceRole", 
-                        versionInt)}));
+                        release)}));
         }
 
         _grantRoleToAccount( 
@@ -171,7 +179,7 @@ contract ReleaseAdmin is
         IServiceAuthorization serviceAuthorization,
         IService service,
         ObjectType serviceDomain, 
-        VersionPart releaseVersion
+        VersionPart release
     )
         private
     {
@@ -189,21 +197,21 @@ contract ReleaseAdmin is
             } else {
                 authorizedRoleId = RoleIdLib.roleForTypeAndVersion(
                 authorizedDomain, 
-                releaseVersion);
+                release);
             }
 
             if(!roleExists(authorizedRoleId)) {
                 // create role for authorized domain
                 _createRole(
                     authorizedRoleId, 
-                    toRole({
+                    AccessAdminLib.toRole({
                         adminRoleId: ADMIN_ROLE(),
                         roleType: RoleType.Contract,
                         maxMemberCount: 1,
                         name: ObjectTypeLib.toVersionedName(
                             ObjectTypeLib.toName(authorizedDomain), 
                             "Role", 
-                            releaseVersion.toInt())}));
+                            release)}));
             }
 
             // get authorized functions for authorized domain
@@ -228,7 +236,7 @@ contract ReleaseAdmin is
 
         _createRole(
             RELEASE_REGISTRY_ROLE(), 
-            toRole({
+            AccessAdminLib.toRole({
                 adminRoleId: ADMIN_ROLE(),
                 roleType: RoleType.Contract,
                 maxMemberCount: 1,
@@ -236,8 +244,8 @@ contract ReleaseAdmin is
 
         FunctionInfo[] memory functions;
         functions = new FunctionInfo[](2);
-        functions[0] = toFunction(ReleaseAdmin.authorizeService.selector, "authorizeService");
-        functions[1] = toFunction(ReleaseAdmin.setServiceLocked.selector, "setServiceLocked");
+        functions[0] = AccessAdminLib.toFunction(ReleaseAdmin.authorizeService.selector, "authorizeService");
+        functions[1] = AccessAdminLib.toFunction(ReleaseAdmin.setServiceLocked.selector, "setServiceLocked");
         _authorizeTargetFunctions(address(this), RELEASE_REGISTRY_ROLE(), functions);
 
         _grantRoleToAccount(RELEASE_REGISTRY_ROLE(), releaseRegistry);

package/contracts/registry/ReleaseRegistry.sol

@@ -4,27 +4,25 @@ pragma solidity ^0.8.20;
 import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 
-import {ContractLib} from "../shared/ContractLib.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, ObjectTypeLib, POOL, RELEASE, REGISTRY, SERVICE, STAKING} from "../type/ObjectType.sol";
-import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
-import {Seconds} from "../type/Seconds.sol";
-import {StateId, SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED} from "../type/StateId.sol";
-import {VersionPart, VersionPartLib} from "../type/Version.sol";
-
-import {IService} from "../shared/IService.sol";
-
 import {IAccessAdmin} from "../authorization/IAccessAdmin.sol";
 import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
-
 import {IRegistry} from "./IRegistry.sol";
 import {IRelease} from "./IRelease.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {IService} from "../shared/IService.sol";
 import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
+
+import {ContractLib} from "../shared/ContractLib.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, ObjectTypeLib, POOL, RELEASE, REGISTRY, SERVICE, STAKING} from "../type/ObjectType.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 import {Registry} from "./Registry.sol";
-import {ReleaseLifecycle} from "./ReleaseLifecycle.sol";
 import {ReleaseAdmin} from "./ReleaseAdmin.sol";
+import {ReleaseLifecycle} from "./ReleaseLifecycle.sol";
+import {Seconds} from "../type/Seconds.sol";
+import {StateId, SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED} from "../type/StateId.sol";
+import {TimestampLib, zeroTimestamp} from "../type/Timestamp.sol";
+import {VersionPart, VersionPartLib} from "../type/Version.sol";
 
 /// @dev The ReleaseRegistry manages the lifecycle of major GIF releases and their services.
 /// The creation of a new GIF release is a multi-step process:
@@ -73,7 +71,7 @@ contract ReleaseRegistry is
     error ErrorReleaseRegistryServiceSelfRegistration(IService service);
     error ErrorReleaseRegistryServiceOwnerRegistered(IService service, address owner);
 
-    RegistryAdmin public immutable _admin;
+    RegistryAdmin public immutable _registryAdmin;
     Registry public immutable _registry;
 
     mapping(VersionPart release => IRelease.ReleaseInfo info) internal _releaseInfo;
@@ -87,6 +85,7 @@ contract ReleaseRegistry is
     uint256 internal _registeredServices = 0;
     uint256 internal _servicesToRegister = 0;
 
+    // TODO move master relase admin outside constructor (same construction as for registry admin)
     constructor(Registry registry)
         AccessManaged(msg.sender)
     {
@@ -97,9 +96,9 @@ contract ReleaseRegistry is
         setAuthority(registry.getAuthority());
 
         _registry = registry;
-        _admin = RegistryAdmin(_registry.getRegistryAdminAddress());
-
-        _masterReleaseAdmin = new ReleaseAdmin();
+        _registryAdmin = RegistryAdmin(_registry.getRegistryAdminAddress());
+        _masterReleaseAdmin = new ReleaseAdmin(
+            _cloneNewAccessManager());
 
         _next = VersionPartLib.toVersionPart(INITIAL_GIF_VERSION - 1);
     }
@@ -253,16 +252,16 @@ contract ReleaseRegistry is
             revert ErrorReleaseRegistryRegistryServiceMissing(release);
         }
 
-        _admin.grantServiceRoleForAllVersions(IService(service), REGISTRY());
+        _registryAdmin.grantServiceRoleForAllVersions(IService(service), REGISTRY());
 
         service = _registry.getServiceAddress(STAKING(), release);
         if(service != address(0)) {
-            _admin.grantServiceRoleForAllVersions(IService(service), STAKING());
+            _registryAdmin.grantServiceRoleForAllVersions(IService(service), STAKING());
         }
 
         service = _registry.getServiceAddress(POOL(), release);
         if(service != address(0)) {
-            _admin.grantServiceRoleForAllVersions(IService(service), POOL());
+            _registryAdmin.grantServiceRoleForAllVersions(IService(service), POOL());
         }
 
         _setReleaseLocked(release, false);
@@ -350,7 +349,7 @@ contract ReleaseRegistry is
     }
 
     function getRegistryAdmin() external view returns (address) {
-        return address(_admin);
+        return address(_registryAdmin);
     }
 
     //--- IRegistryLinked ------------------------------------------------------//
@@ -368,24 +367,23 @@ contract ReleaseRegistry is
             _releaseInfo[release].releaseAdmin).setReleaseLocked(locked);
     }
 
-
     function _cloneNewReleaseAdmin(VersionPart release)
         private
         returns (ReleaseAdmin clonedAdmin)
     {
-        AccessManagerCloneable clonedAccessManager = AccessManagerCloneable(
-            Clones.clone(
-                _masterReleaseAdmin.authority()
-            )
-        );
-
+        // clone and setup release specific release admin
         clonedAdmin = ReleaseAdmin(
-            Clones.clone(
-                address(_masterReleaseAdmin)
-            )
-        );
+            Clones.clone(address(_masterReleaseAdmin)));
+
+        string memory releaseAdminName = string(
+            abi.encodePacked(
+                "ReleaseAdmin_v", 
+                release.toString()));
+
+        clonedAdmin.initialize(
+            address(_cloneNewAccessManager()),
+            releaseAdminName);
 
-        clonedAdmin.initialize(clonedAccessManager);
         clonedAdmin.completeSetup(
             address(_registry), 
             address(this), // release registry (this contract)
@@ -396,6 +394,14 @@ contract ReleaseRegistry is
     }
 
 
+    function _cloneNewAccessManager()
+        private
+        returns (address accessManager)
+    {
+        return Clones.clone(address(_registryAdmin.authority()));
+    }
+
+
     function _verifyServiceAuthorization(
         IServiceAuthorization serviceAuthorization,
         VersionPart releaseVersion,
@@ -407,7 +413,7 @@ contract ReleaseRegistry is
     {
         // authorization contract supports IServiceAuthorization interface
         if(!serviceAuthorization.supportsInterface(type(IServiceAuthorization).interfaceId)) {
-                revert ErrorReleaseRegistryNotServiceAuth(address(serviceAuthorization));
+            revert ErrorReleaseRegistryNotServiceAuth(address(serviceAuthorization));
         }
 
         // authorizaions contract version matches with release version