@etherisc/gif-next 0.0.2-d7cec72-860 → 0.0.2-d81839a-779

package/contracts/registry/RegistryAuthorization.sol

@@ -0,0 +1,336 @@
+// 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 {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";
+     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_TARGET_HANDLER_NAME = "TargetHandler";
+     string public constant STAKING_STORE_TARGET_NAME = "StakingStore";
+     string public constant STAKING_TH_TARGET_NAME = "StakingTh";
+
+     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 {
+
+          // max number of versioned contracts per generic service
+          uint32 maxReleases = uint32(VersionPartLib.releaseMax().toInt());
+
+          // service roles (for all releases)
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(REGISTRY()), 
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
+                    name: REGISTRY_SERVICE_ROLE_NAME}));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(STAKING()), 
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Core,
+                    maxMemberCount: maxReleases, 
+                    name: STAKING_SERVICE_ROLE_NAME}));
+
+          _addRole(
+               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.Core,
+                    maxMemberCount: maxReleases, 
+                    name: POOL_SERVICE_ROLE_NAME}));
+
+          // gif admin role
+          _addRole(
+               GIF_ADMIN_ROLE(),
+               _toRoleInfo({
+                    adminRoleId: ADMIN_ROLE(),
+                    roleType: RoleType.Core,
+                    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.Core,
+                    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 {
+          _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);
+     }
+
+
+     function _setupTargetAuthorizations()
+          internal
+          override
+     {
+          // registry
+          _setupRegistryAuthorization();
+          _setupRegistryAdminAuthorization();
+          _setupReleaseRegistryAuthorization();
+          _setupTokenRegistryAuthorization();
+
+          // staking
+          _setupStakingAuthorization();
+          _setupStakingTargetHandlerAuthorization();
+          _setupStakingStoreAuthorization();
+          _setupStakingThAuthorization();
+     }
+
+     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.toGenericServiceRoleId(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 (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.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.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.toGenericServiceRoleId(POOL()));
+
+          _authorize(functions, IStaking.increaseTotalValueLocked.selector, "increaseTotalValueLocked");
+          _authorize(functions, IStaking.decreaseTotalValueLocked.selector, "decreaseTotalValueLocked");
+     }
+
+
+     function _setupStakingTargetHandlerAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // staking service role
+          functions = _authorizeForTarget(
+               STAKING_TARGET_HANDLER_NAME,
+               getTargetRole(getTarget(STAKING_TARGET_NAME)));
+
+          _authorize(functions, TargetHandler.setUpdateTriggers.selector, "setUpdateTriggers");
+     }
+
+
+     function _setupStakingStoreAuthorization() internal {
+          IAccess.FunctionInfo[] storage functions;
+
+          // release registry role
+          functions = _authorizeForTarget(
+               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.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.createStake.selector, "createStake");
+          _authorize(functions, StakingStore.stake.selector, "stake");
+          _authorize(functions, StakingStore.unstake.selector, "unstake");
+          _authorize(functions, StakingStore.updateRewards.selector, "updateRewards");
+          _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

@@ -1,39 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-// import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
-
-import {IRegistry} from "./IRegistry.sol";
-import {IInstance} from "../instance/IInstance.sol";
-
 import {IComponent} from "../../contracts/shared/IComponent.sol";
+import {IDistributionComponent} from "../../contracts/distribution/IDistributionComponent.sol";
+import {IInstance} from "../instance/IInstance.sol";
 import {IPoolComponent} from "../../contracts/pool/IPoolComponent.sol";
 import {IProductComponent} from "../../contracts/product/IProductComponent.sol";
-import {IDistributionComponent} from "../../contracts/distribution/IDistributionComponent.sol";
-
-import {IVersionable} from "../../contracts/shared/IVersionable.sol";
-import {Versionable} from "../../contracts/shared/Versionable.sol";
 import {IRegisterable} from "../../contracts/shared/IRegisterable.sol";
+import {IRegistry} from "./IRegistry.sol";
+import {IRegistryService} from "./IRegistryService.sol";
 
-import {RoleId, PRODUCT_OWNER_ROLE, POOL_OWNER_ROLE, ORACLE_OWNER_ROLE} from "../../contracts/type/RoleId.sol";
 import {ObjectType, REGISTRY, SERVICE, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKE, STAKING, PRICE} from "../../contracts/type/ObjectType.sol";
-import {StateId, ACTIVE, PAUSED} from "../../contracts/type/StateId.sol";
 import {NftId, NftIdLib} from "../../contracts/type/NftId.sol";
-import {Fee, FeeLib} from "../../contracts/type/Fee.sol";
-import {Version, VersionPart, VersionLib} from "../../contracts/type/Version.sol";
-
 import {Service} from "../shared/Service.sol";
-import {IService} from "../shared/IService.sol";
-import {IRegistryService} from "./IRegistryService.sol";
-import {Registry} from "./Registry.sol";
 
 contract RegistryService is
     Service,
     IRegistryService
 {
-    using NftIdLib for NftId;
-
     // TODO update to real hash when registry is stable
     bytes32 public constant REGISTRY_CREATION_CODE_HASH = bytes32(0);
 
@@ -46,15 +30,15 @@ contract RegistryService is
     )
         internal
         virtual override
-        initializer()
+        onlyInitializing
     {
         (
-            address registryAddress,
-            address initialAuthority
+            address authority,
+            address registry
         ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, initialAuthority, owner);
-        registerInterface(type(IRegistryService).interfaceId);
+        __Service_init(authority, registry, owner);
+        _registerInterface(type(IRegistryService).interfaceId);
     }
 
 
@@ -74,7 +58,7 @@ contract RegistryService is
     function registerInstance(IRegisterable instance, address owner)
         external
         virtual
-        restricted
+        restricted()
         returns(
             IRegistry.ObjectInfo memory info
         ) 
@@ -89,29 +73,33 @@ contract RegistryService is
         instance.linkToRegisteredNftId(); // asume safe
     }
 
-    function registerProduct(IComponent product, address owner)
+    function registerProduct(
+        IComponent product, 
+        address initialOwner
+    )
         external
-        restricted
+        virtual
+        restricted()
         returns(
             IRegistry.ObjectInfo memory info
         ) 
     {
-        // CAN revert if no ERC165 support -> will revert with empty message 
         if(!product.supportsInterface(type(IProductComponent).interfaceId)) {
             revert ErrorRegistryServiceNotProduct(address(product));
         }
 
-        info = _getAndVerifyContractInfo(product, PRODUCT(), owner);
+        info = _getAndVerifyContractInfo(product, PRODUCT(), initialOwner);
         info.nftId = getRegistry().register(info);
     }
 
-    function registerComponent(
+    function registerProductLinkedComponent(
         IComponent component, 
         ObjectType objectType,
         address initialOwner
     )
         external
-        restricted
+        virtual
+        restricted()
         returns(
             IRegistry.ObjectInfo memory info
         ) 
@@ -121,43 +109,18 @@ contract RegistryService is
             revert ErrorRegistryServiceNotComponent(address(component));
         }
 
-        info = _getAndVerifyContractInfo(component, objectType, initialOwner);
-        info.nftId = getRegistry().register(info);
-    }
-
-    function registerPool(IComponent pool, address owner)
-        external
-        restricted
-        returns(
-            IRegistry.ObjectInfo memory info
-        ) 
-    {
-        if(!pool.supportsInterface(type(IPoolComponent).interfaceId)) {
-            revert ErrorRegistryServiceNotPool(address(pool));
-        }
-
-        info = _getAndVerifyContractInfo(pool, POOL(), owner);
-        info.nftId = getRegistry().register(info);
-    }
-
-    function registerDistribution(IComponent distribution, address owner)
-        external
-        restricted
-        returns(
-            IRegistry.ObjectInfo memory info
-        ) 
-    {
-        if(!distribution.supportsInterface(type(IDistributionComponent).interfaceId)) {
-            revert ErrorRegistryServiceNotDistribution(address(distribution));
+        if (!(objectType == DISTRIBUTION() || objectType == ORACLE() || objectType == POOL())) {
+            revert ErrorRegistryServiceNotProductLinkedComponent(address(component));
         }
 
-        info = _getAndVerifyContractInfo(distribution, DISTRIBUTION(), owner);
+        info = _getAndVerifyContractInfo(component, objectType, initialOwner);
         info.nftId = getRegistry().register(info);
     }
 
     function registerDistributor(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, DISTRIBUTOR());
@@ -166,7 +129,8 @@ contract RegistryService is
 
     function registerPolicy(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, POLICY());
@@ -175,7 +139,8 @@ contract RegistryService is
 
     function registerBundle(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, BUNDLE());
@@ -184,7 +149,8 @@ contract RegistryService is
 
     function registerStake(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, STAKE());
@@ -199,6 +165,7 @@ contract RegistryService is
         address expectedOwner // assume can be 0 when given by other service
     )
         internal
+        virtual
         view
         returns(
             IRegistry.ObjectInfo memory info 
@@ -238,6 +205,7 @@ contract RegistryService is
         ObjectType expectedType
     )
         internal
+        virtual
         view
     {
         if(info.objectAddress > address(0)) {
@@ -254,8 +222,15 @@ contract RegistryService is
             revert ErrorRegistryServiceObjectOwnerZero(info.objectType);
         }
 
-        if(getRegistry().isRegistered(owner)) { 
-            revert ErrorRegistryServiceObjectOwnerRegistered(info.objectType, owner);
+        if(owner == msg.sender) {
+            revert ErrorRegistryServiceInvalidInitialOwner(owner);
+        }
+
+        if(getRegistry().isRegistered(owner)) {
+            ObjectType ownerType = getRegistry().getObjectInfo(owner).objectType;
+            if(ownerType == REGISTRY() || ownerType == STAKING() || ownerType == SERVICE() || ownerType == INSTANCE()) {
+                revert ErrorRegistryServiceObjectOwnerRegistered(info.objectType, owner);
+            }
         }
     }
 

package/contracts/registry/RegistryServiceManager.sol

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IVersionable} from "../shared/IVersionable.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
+import {IVersionable} from "../upgradeability/IVersionable.sol";
+import {ProxyManager} from "../upgradeability/ProxyManager.sol";
 import {RegistryService} from "./RegistryService.sol";
 
 contract RegistryServiceManager is
@@ -21,7 +21,6 @@ contract RegistryServiceManager is
         address registry, // used by implementation 
         bytes32 salt
     ) 
-        ProxyManager(registry)
     {
         if(authority == address(0)) {
             revert ErrorRegistryAccessManagerAuthorityZero();
@@ -32,8 +31,9 @@ contract RegistryServiceManager is
         }
         
         RegistryService srv = new RegistryService{ salt: salt }();
-        bytes memory data = abi.encode(registry, authority);
-        IVersionable versionable = deployDetermenistic(
+        bytes memory data = abi.encode(authority, registry);
+        IVersionable versionable = initialize(
+            registry,
             address(srv), 
             data,
             salt);