@etherisc/gif-next 0.0.2-ead1eb0-841 → 0.0.2-eadf4ad-211

package/contracts/registry/RegistryAccessManager.sol

@@ -1,31 +1,24 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.20;
 
-import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
+import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
+import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
+import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+
+import {RoleId, RoleIdLib, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE} from "../type/RoleId.sol";
 
-import {RoleId, RoleIdLib,
-        GIF_MANAGER_ROLE,
-        GIF_ADMIN_ROLE,
-        RELEASE_MANAGER_ROLE} from "../type/RoleId.sol";
+import {AccessManagerUpgradeableInitializeable} from "../shared/AccessManagerUpgradeableInitializeable.sol";
 
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {ReleaseManager} from "./ReleaseManager.sol";
 
 /*
-    4 types of roles:
-    1) RELEASE_MANAGER_ROLE
-        - has only ReleaseManager as member
-        - responsible for setting and granting of REGISTRAR roles
-    1) REGISTRAR roles
-        - set and granted by RELEASE_MANAGER_ROLE
-        - for each service and major version X there is 1 unique member (the service with version X itself) (subject to change)
-        - each set to 1 target (registry service ver.X) and 1 selector (function of registry service ver.X) (subject to change)
-    2) GIF_MANAGER_ROLE
+    1) GIF_MANAGER_ROLE
         - can have arbitrary number of members
         - responsible for services registrations
         - responsible for token registration and activation
-    3) GIF_ADMIN_ROLE
+    2) GIF_ADMIN_ROLE
         - admin of GIF_MANAGER_ROLE
         - MUST have 1 member at any time
         - granted/revoked ONLY in transferAdminRole() -> consider lock out situations!!!
@@ -33,95 +26,52 @@ import {ReleaseManager} from "./ReleaseManager.sol";
 
 */
 
-contract RegistryAccessManager is AccessManaged
+contract RegistryAccessManager is AccessManaged, Initializable
 {
-    error NotInitialized();
-    error AlreadyInitialized();
+    error ErrorRegistryAccessManagerReleaseManagerAuthorityMismatch();
+    error ErrorRegistryAccessManagerTokenRegistryZero();
 
     uint64 public constant UNIQUE_ROLE_ID_MIN = 1000000;
     
-    AccessManager private immutable _accessManager;
     address private _releaseManager;
     address private _tokenRegistry;
 
     uint64 private _idNext; // role id
-    bool private _isInitialized;
-
-    modifier onlyOnce() {
-        if(_isInitialized) {
-            revert AlreadyInitialized();
-        } 
-        _;
-        _isInitialized = true;
-    }
 
-    modifier onlyInitialized() {
-        if(!_isInitialized) {
-            revert NotInitialized();
-        }
-        _;
-    }
 
-    constructor(address manager)
+    // IMPORTNAT: this.authority() must be valid before initialize() function....
+    // -> have constructor and initializer function
+    constructor()
         AccessManaged(msg.sender)
     {
-        _accessManager = new AccessManager(address(this));
-        setAuthority(address(_accessManager));
-
-        _idNext = UNIQUE_ROLE_ID_MIN;
-
-        _configureAdminRoleInitial();
-
-        address admin = msg.sender;
-        _grantRole(GIF_ADMIN_ROLE(), admin, 0);
-        _grantRole(GIF_MANAGER_ROLE(), manager, 0);
+        AccessManagerUpgradeableInitializeable accessManager = new AccessManagerUpgradeableInitializeable();
+        accessManager.initialize(address(this));
+        setAuthority(address(accessManager));
     }
 
-    function initialize(address releaseManager, address tokenRegistry)
-        external 
-        restricted // GIF_ADMIN_ROLE
-        onlyOnce
+    function initialize(address admin, address manager, address releaseManager, address tokenRegistry)
+        external
+        initializer
     {
-        require(
-            ReleaseManager(releaseManager).authority() == address(_accessManager),
-            "RegistryAccessManager: release manager authority is invalid");
-        require(tokenRegistry > address(0), "RegistryAccessManager: token registry is 0");
-        //require(tokenRegistry.authority() == address(_accessManager));
+        // validate input
+        if(IAccessManaged(releaseManager).authority() != authority()) {
+            revert ErrorRegistryAccessManagerReleaseManagerAuthorityMismatch();
+        }
+        if(tokenRegistry == address(0)) {
+            revert ErrorRegistryAccessManagerTokenRegistryZero();
+        }
 
         _releaseManager = releaseManager;
         _tokenRegistry = tokenRegistry;
+        _idNext = UNIQUE_ROLE_ID_MIN;
 
-        _configureAdminRole();
-        _configureManagerRole();
-        _configureReleaseManagerRole();
+        _setAdminRole();
+        _setManagerRole();
 
-        _grantRole(RELEASE_MANAGER_ROLE(), releaseManager, 0);
-    }
+        _grantRole(GIF_ADMIN_ROLE(), admin, 0);
+        _grantRole(GIF_MANAGER_ROLE(), manager, 0);
 
-    // set unique role for target, role forever have 1 member and never revoked
-    function setAndGrantUniqueRole(
-        address account, 
-        address target, 
-        bytes4[] memory selector
-    )
-        external
-        restricted // RELEASE_MANAGER_ROLE
-        onlyInitialized
-        returns(RoleId)
-    {
-        // TODO questionable check...
-        // target is not part of `runtime`
-        //if(
-        //    target == address(this) ||
-        //    target == address(_accessManager) || 
-        //    target == _releaseManager || 
-        //    target == _tokenRegistry)
-        //{ return TargetInvalid(); }
-
-        RoleId roleId = _getNextRoleId();
-
-        _setTargetFunctionRole(target, selector, roleId);
-        _grantRole(roleId, account, 0);
+        _setRoleAdmin(GIF_MANAGER_ROLE(), GIF_ADMIN_ROLE());
     }
 
     /*function transferAdmin(address to)
@@ -134,35 +84,12 @@ contract RegistryAccessManager is AccessManaged
 
     //--- view functions ----------------------------------------------------//
 
-    function getAccessManager()
-        external
-        view
-        returns (AccessManager)
-    {
-        return _accessManager;
-    }
-
     //--- private functions -------------------------------------------------//
 
-    function _configureAdminRoleInitial() private
-    {
-        bytes4[] memory functionSelector = new bytes4[](1);
-
-        functionSelector[0] = RegistryAccessManager.initialize.selector;
-        _setTargetFunctionRole(address(this), functionSelector, GIF_ADMIN_ROLE());
-    }
-
-    function _configureAdminRole() private
+    function _setAdminRole() private
     {
         bytes4[] memory functionSelector = new bytes4[](1);
 
-        // for RegistryServiceProxyManager
-        // TODO upgrading with releaseManager.upgrade()->proxy.upgrade()???
-        //functionSelector[0] = RegistryServiceManager.upgrade.selector;
-        //_setTargetFunctionRole(address(this), functionSelector, GIF_ADMIN_ROLE());
-
-        // for TokenRegistry
-
         // for ReleaseManager
         functionSelector[0] = ReleaseManager.createNextRelease.selector;
         _setTargetFunctionRole(_releaseManager, functionSelector, GIF_ADMIN_ROLE());
@@ -171,7 +98,7 @@ contract RegistryAccessManager is AccessManaged
         _setTargetFunctionRole(_releaseManager, functionSelector, GIF_ADMIN_ROLE());
     }
     
-    function _configureManagerRole() private 
+    function _setManagerRole() private 
     {
         bytes4[] memory functionSelector = new bytes4[](1);
 
@@ -183,31 +110,20 @@ contract RegistryAccessManager is AccessManaged
         functionSelector[0] = ReleaseManager.registerService.selector;
         _setTargetFunctionRole(_releaseManager, functionSelector, GIF_MANAGER_ROLE());
 
-        functionSelector[0] = ReleaseManager.registerRegistryService.selector;
+        functionSelector[0] = ReleaseManager.prepareNextRelease.selector;
         _setTargetFunctionRole(_releaseManager, functionSelector, GIF_MANAGER_ROLE());
-
-        // set admin
-        _setRoleAdmin(GIF_MANAGER_ROLE(), GIF_ADMIN_ROLE());
-    }
-
-    function _configureReleaseManagerRole() private
-    {
-        bytes4[] memory functionSelector = new bytes4[](1);
-
-        functionSelector[0] = RegistryAccessManager.setAndGrantUniqueRole.selector;
-        _setTargetFunctionRole(address(this), functionSelector, RELEASE_MANAGER_ROLE());
     }
 
     function _setTargetFunctionRole(address target, bytes4[] memory selectors, RoleId roleId) private {
-        _accessManager.setTargetFunctionRole(target, selectors, roleId.toInt());        
+        AccessManager(authority()).setTargetFunctionRole(target, selectors, roleId.toInt());        
     }
 
     function _setRoleAdmin(RoleId roleId, RoleId adminRoleId) private {
-        _accessManager.setRoleAdmin(roleId.toInt(), adminRoleId.toInt());
+        AccessManager(authority()).setRoleAdmin(roleId.toInt(), adminRoleId.toInt());
     }
 
     function _grantRole(RoleId roleId, address account, uint32 executionDelay) private {
-            _accessManager.grantRole(roleId.toInt(), account, executionDelay);
+        AccessManager(authority()).grantRole(roleId.toInt(), account, executionDelay);
     }
 
     function _getNextRoleId() private returns(RoleId roleId) {

package/contracts/registry/RegistryService.sol

@@ -54,13 +54,12 @@ contract RegistryService is
         virtual override
         initializer()
     {
-        (
-            address registryAddress,
-            address initialAuthority
-        ) = abi.decode(data, (address, address));
-
-        initializeService(registryAddress, initialAuthority, owner);
+        address initialOwner;
+        address registryAddress;
+        address authority;
+        (registryAddress, initialOwner, authority) = abi.decode(data, (address, address, address));
 
+        initializeService(registryAddress, authority, owner);
         registerInterface(type(IRegistryService).interfaceId);
     }
 
@@ -72,7 +71,7 @@ contract RegistryService is
         ) 
     {
         if(!instance.supportsInterface(type(IInstance).interfaceId)) {
-            revert NotInstance();
+            revert ErrorRegistryServiceNotInstance(address(instance));
         }
 
         info = _getAndVerifyContractInfo(instance, INSTANCE(), owner);
@@ -90,7 +89,7 @@ contract RegistryService is
     {
         // CAN revert if no ERC165 support -> will revert with empty message 
         if(!product.supportsInterface(type(IProductComponent).interfaceId)) {
-            revert NotProduct();
+            revert ErrorRegistryServiceNotProduct(address(product));
         }
 
         info = _getAndVerifyContractInfo(product, PRODUCT(), owner);
@@ -105,7 +104,7 @@ contract RegistryService is
         ) 
     {
         if(!pool.supportsInterface(type(IPoolComponent).interfaceId)) {
-            revert NotPool();
+            revert ErrorRegistryServiceNotPool(address(pool));
         }
 
         info = _getAndVerifyContractInfo(pool, POOL(), owner);
@@ -120,7 +119,7 @@ contract RegistryService is
         ) 
     {
         if(!distribution.supportsInterface(type(IDistributionComponent).interfaceId)) {
-            revert NotDistribution();
+            revert ErrorRegistryServiceNotDistribution(address(distribution));
         }
 
         info = _getAndVerifyContractInfo(distribution, DISTRIBUTION(), owner);
@@ -142,7 +141,6 @@ contract RegistryService is
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, POLICY());
-
         nftId = getRegistry().register(info);
     }
 
@@ -152,7 +150,6 @@ contract RegistryService is
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, BUNDLE());
-
         nftId = getRegistry().register(info);
     }
 
@@ -162,63 +159,9 @@ contract RegistryService is
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, STAKE());
-
         nftId = getRegistry().register(info);
     }
 
-    // from IRegisterable
-
-    function getFunctionConfigs()
-        external
-        pure
-        returns(
-            FunctionConfig[] memory config
-        )
-    {
-        config = new FunctionConfig[](9);
-
-        // order of service registrations MUST be reverse to this array 
-        /*config[-1].serviceDomain = STAKE();
-        config[-1].selector = RegistryService.registerStake.selector;*/
-
-        config[0].serviceDomain = POLICY();
-        config[0].selectors = new bytes4[](0);
-
-        config[1].serviceDomain = APPLICATION();
-        config[1].selectors = new bytes4[](1);
-        config[1].selectors[0] = RegistryService.registerPolicy.selector;
-
-        config[2].serviceDomain = CLAIM();
-        config[2].selectors = new bytes4[](0);
-
-        config[3].serviceDomain = PRODUCT();
-        config[3].selectors = new bytes4[](1);
-        config[3].selectors[0] = RegistryService.registerProduct.selector;
-
-        config[4].serviceDomain = POOL();
-        config[4].selectors = new bytes4[](1);
-        config[4].selectors[0] = RegistryService.registerPool.selector;
-
-        // registration of bundle service must preceed registration of pool service
-        config[5].serviceDomain = BUNDLE();
-        config[5].selectors = new bytes4[](1);
-        config[5].selectors[0] = RegistryService.registerBundle.selector;
-
-        // registration of pricing service must preceed registration of application service
-        config[6].serviceDomain = PRICE();
-        config[6].selectors = new bytes4[](0);
-
-        // registration of distribution service must preceed registration of pricing service
-        config[7].serviceDomain = DISTRIBUTION();
-        config[7].selectors = new bytes4[](2);
-        config[7].selectors[0] = RegistryService.registerDistribution.selector;
-        config[7].selectors[1] = RegistryService.registerDistributor.selector;
-
-        config[8].serviceDomain = INSTANCE();
-        config[8].selectors = new bytes4[](1);
-        config[8].selectors[0] = RegistryService.registerInstance.selector;
-    }
-
     // Internal
 
     function _getAndVerifyContractInfo(
@@ -227,34 +170,37 @@ contract RegistryService is
         address expectedOwner // assume can be 0 when given by other service
     )
         internal
-        // view
+        view
         returns(
             IRegistry.ObjectInfo memory info 
         )
     {
         info = registerable.getInitialInfo();
-        info.objectAddress = address(registerable);
+
+        if(info.objectAddress != address(registerable)) {
+            revert ErrorRegistryServiceRegisterableAddressInvalid(registerable, info.objectAddress);
+        }
 
         if(info.objectType != expectedType) {// type is checked in registry anyway...but service logic may depend on expected value
-            revert UnexpectedRegisterableType(expectedType, info.objectType);
+            revert ErrorRegistryServiceRegisterableTypeInvalid(registerable, expectedType, info.objectType);
         }
 
         address owner = info.initialOwner;
 
         if(owner != expectedOwner) { // registerable owner protection
-            revert NotRegisterableOwner(expectedOwner);
+            revert ErrorRegistryServiceRegisterableOwnerInvalid(registerable, expectedOwner, owner);
         }
 
         if(owner == address(registerable)) {
-            revert SelfRegistration();
+            revert ErrorRegistryServiceRegisterableSelfRegistration(registerable);
         }
 
         if(owner == address(0)) {
-            revert RegisterableOwnerIsZero();
+            revert ErrorRegistryServiceRegisterableOwnerZero(registerable);
         }
         
         if(getRegistry().isRegistered(owner)) { 
-            revert RegisterableOwnerIsRegistered();
+            revert ErrorRegistryServiceRegisterableOwnerRegistered(registerable, owner);
         }
     }
 
@@ -269,17 +215,17 @@ contract RegistryService is
         info.objectAddress = address(0);
 
         if(info.objectType != expectedType) {// type is checked in registry anyway...but service logic may depend on expected value
-            revert UnexpectedRegisterableType(expectedType, info.objectType);
+            revert ErrorRegistryServiceObjectTypeInvalid(expectedType, info.objectType);
         }
 
         address owner = info.initialOwner;
 
         if(owner == address(0)) {
-            revert RegisterableOwnerIsZero();
+            revert ErrorRegistryServiceObjectOwnerZero(info.objectType);
         }
 
         if(getRegistry().isRegistered(owner)) { 
-            revert RegisterableOwnerIsRegistered();
+            revert ErrorRegistryServiceObjectOwnerRegistered(info.objectType, owner);
         }
     }
 }

package/contracts/registry/RegistryServiceManager.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 
 import {Registry} from "./Registry.sol";
 import {IVersionable} from "../shared/IVersionable.sol";
@@ -13,25 +14,36 @@ import {TokenRegistry} from "./TokenRegistry.sol";
 contract RegistryServiceManager is
     ProxyManager
 {
+    error ErrorRegistryAccessManagerAuthorityZero();
+    error ErrorRegistryAccessManagerRegistryZero();
+
     bytes32 constant public ACCESS_MANAGER_CREATION_CODE_HASH = 0x0;
 
     RegistryService private immutable _registryService;
 
     /// @dev initializes proxy manager with registry service implementation and deploys registry
     constructor(
-        address initialAuthority, // used by implementation 
-        address registryAddress) // used by implementation 
-        ProxyManager(registryAddress)
+        address authority, // used by implementation 
+        address registry, // used by implementation 
+        bytes32 salt
+    ) 
+        ProxyManager(registry)
     {
-        require(initialAuthority > address(0), "RegistryServiceManager: initial authority is 0");
-        require(registryAddress > address(0), "RegistryServiceManager: registry is 0");
+        if(authority == address(0)) {
+            revert ErrorRegistryAccessManagerAuthorityZero();
+        }
+
+        if(registry == address(0)) {
+            revert ErrorRegistryAccessManagerRegistryZero();
+        }
         
         // implementation's initializer func `data` argument
-        RegistryService srv = new RegistryService();
-        bytes memory data = abi.encode(registryAddress, initialAuthority);
-        IVersionable versionable = deploy(
+        RegistryService srv = new RegistryService{ salt: salt }();
+        bytes memory data = abi.encode(registry, address(this), authority);
+        IVersionable versionable = deployDetermenistic(
             address(srv), 
-            data);
+            data,
+            salt);
 
         _registryService = RegistryService(address(versionable));