@etherisc/gif-next 0.0.2-c8c9cfc-245 → 0.0.2-c9577b6-545

package/contracts/registry/RegistryAdmin.sol

@@ -7,11 +7,11 @@ import {IRegistry} from "./IRegistry.sol";
 import {IService} from "../shared/IService.sol";
 import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
 import {IStaking} from "../staking/IStaking.sol";
-import {ObjectType, ObjectTypeLib, ALL, POOL, RELEASE} from "../type/ObjectType.sol";
+import {ObjectType, ObjectTypeLib, ALL, 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 {StakingStore} from "../staking/StakingStore.sol";
-import {STAKING} from "../type/ObjectType.sol";
+import {TokenHandler} from "../shared/TokenHandler.sol";
 import {TokenRegistry} from "./TokenRegistry.sol";
 import {VersionPart} from "../type/Version.sol";
 
@@ -26,37 +26,33 @@ import {VersionPart} from "../type/Version.sol";
         - MUST have 1 member at any time
         - granted/revoked ONLY in transferAdminRole() -> consider lock out situations!!!
         - responsible for creation and activation of releases
-
-    createServiceTarget(type, release)
-    createServiceRole(type,release)
-    getServiceRole(type, release)
 */
 contract RegistryAdmin is
     AccessAdmin
 {
-    error ErrorRegistryAdminIsAlreadySetUp();
-
     string public constant GIF_ADMIN_ROLE_NAME = "GifAdminRole";
     string public constant GIF_MANAGER_ROLE_NAME = "GifManagerRole";
     string public constant POOL_SERVICE_ROLE_NAME = "PoolServiceRole";
     string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistryRole";
+    string public constant REGISTRY_SERVICE_ROLE_NAME = "RegistryServiceRole";
     string public constant STAKING_SERVICE_ROLE_NAME = "StakingServiceRole";
     string public constant STAKING_ROLE_NAME = "StakingRole";
 
+    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_STORE_TARGET_NAME = "StakingStore";
 
     uint8 public constant MAX_NUM_RELEASES = 99;
-
+    // TODO consider deleting this
     mapping(address service => VersionPart majorVersion) private _ServiceRelease;
 
+    address internal _registry;
     address private _releaseRegistry;
     address private _tokenRegistry;
     address private _staking;
     address private _stakingStore;
-    bool private _setupCompleted;
 
     constructor() AccessAdmin() { }
 
@@ -66,11 +62,10 @@ contract RegistryAdmin is
         address gifManager
     )
         external
+        initializer
         onlyDeployer()
     {
-        if (_setupCompleted) { revert ErrorRegistryAdminIsAlreadySetUp(); } 
-        else { _setupCompleted = true; }
-
+        _registry = address(registry);
         _releaseRegistry = registry.getReleaseRegistryAddress();
         _tokenRegistry = registry.getTokenRegistryAddress();
         _staking = registry.getStakingAddress();
@@ -84,6 +79,7 @@ contract RegistryAdmin is
         _setupGifManagerRole(gifManager);
 
         _setupReleaseRegistry();
+        _setupRegistry();
         _setupStaking();
     }
 
@@ -93,15 +89,31 @@ contract RegistryAdmin is
     /// Permissioned function: Access is restricted to release manager.
     function authorizeService(
         IServiceAuthorization serviceAuthorization,
-        IService service
+        IService service,
+        ObjectType serviceDomain,
+        VersionPart releaseVersion
     )
         external
         restricted()
     {
-        _createServiceTargetAndRole(service);
-        _authorizeServiceFunctions(serviceAuthorization, service);
+        _createServiceTargetAndRole(service, serviceDomain, releaseVersion);
+        _authorizeServiceFunctions(serviceAuthorization, service, serviceDomain, releaseVersion);
     }
 
+    function grantServiceRole(
+        IService service,
+        ObjectType domain, 
+        VersionPart version
+    )
+        external
+        restricted()
+    {
+        _grantRoleToAccount( 
+            RoleIdLib.roleForTypeAndVersion(
+                domain, 
+                version),
+            address(service)); 
+    }
 
     function grantServiceRoleForAllVersions(IService service, ObjectType domain)
         external
@@ -112,14 +124,42 @@ contract RegistryAdmin is
             address(service)); 
     }
 
+    function setServiceLocked(IService service, bool locked)
+        external
+        restricted()
+    {
+        _setTargetClosed(address(service), locked);
+    }
 
-    function _createServiceTargetAndRole(IService service)
+    /*function transferAdmin(address to)
+        external
+        restricted // only with GIF_ADMIN_ROLE or nft owner
+    {
+        _accessManager.revoke(GIF_ADMIN_ROLE, );
+        _accesssManager.grant(GIF_ADMIN_ROLE, to, 0);
+    }*/
+
+    //--- view functions ----------------------------------------------------//
+
+    function getGifAdminRole() external view returns (RoleId) {
+        return GIF_ADMIN_ROLE();
+    }
+
+    function getGifManagerRole() external view returns (RoleId) {
+        return GIF_MANAGER_ROLE();
+    }
+
+    //--- private functions -------------------------------------------------//
+
+    function _createServiceTargetAndRole(
+        IService service, 
+        ObjectType serviceDomain, 
+        VersionPart releaseVersion
+    )
         private
     {
-        ObjectType serviceDomain = service.getDomain();
         string memory baseName = ObjectTypeLib.toName(serviceDomain);
-        VersionPart version = service.getVersion().toMajorPart();
-        uint256 versionInt = version.toInt();
+        uint256 versionInt = releaseVersion.toInt();
 
         // create service target
         string memory serviceTargetName = ObjectTypeLib.toVersionedName(
@@ -131,10 +171,12 @@ contract RegistryAdmin is
             true,
             false);
 
+        _setTargetClosed(address(service), true);
+
         // create service role
         RoleId serviceRoleId = RoleIdLib.roleForTypeAndVersion(
             serviceDomain, 
-            version);
+            releaseVersion);
 
         _createRole(
             serviceRoleId, 
@@ -155,15 +197,15 @@ contract RegistryAdmin is
 
     function _authorizeServiceFunctions(
         IServiceAuthorization serviceAuthorization,
-        IService service
+        IService service,
+        ObjectType serviceDomain, 
+        VersionPart releaseVersion
     )
         private
     {
-        ObjectType serviceDomain = service.getDomain();
         ObjectType authorizedDomain;
         RoleId authorizedRoleId;
 
-        VersionPart release = service.getVersion().toMajorPart();
         ObjectType[] memory authorizedDomains = serviceAuthorization.getAuthorizedDomains(serviceDomain);
 
         for (uint256 i = 0; i < authorizedDomains.length; i++) {
@@ -175,7 +217,7 @@ contract RegistryAdmin is
             } else {
                 authorizedRoleId = RoleIdLib.roleForTypeAndVersion(
                 authorizedDomain, 
-                release);
+                releaseVersion);
             }
 
             // get authorized functions for authorized domain
@@ -190,27 +232,12 @@ contract RegistryAdmin is
         }
     }
 
-    /*function transferAdmin(address to)
-        external
-        restricted // only with GIF_ADMIN_ROLE or nft owner
-    {
-        _accessManager.revoke(GIF_ADMIN_ROLE, );
-        _accesssManager.grant(GIF_ADMIN_ROLE, to, 0);
-    }*/
-
-    //--- view functions ----------------------------------------------------//
-
-    function getGifAdminRole() external view returns (RoleId) {
-        return GIF_ADMIN_ROLE();
-    }
-
-    function getGifManagerRole() external view returns (RoleId) {
-        return GIF_MANAGER_ROLE();
-    }
+    //--- private initialization functions -------------------------------------------//
 
-    //--- private functions -------------------------------------------------//
-
-    function _setupGifAdminRole(address gifAdmin) private {
+    function _setupGifAdminRole(address gifAdmin) 
+        private 
+        onlyInitializing()
+    {
         
         _createRole(
             GIF_ADMIN_ROLE(), 
@@ -220,8 +247,13 @@ contract RegistryAdmin is
                 maxMemberCount: 2, // TODO decide on max member count
                 name: GIF_ADMIN_ROLE_NAME}));
 
-        // for ReleaseRegistry
+        // for Registry
         FunctionInfo[] memory functions;
+        functions = new FunctionInfo[](1);
+        functions[0] = toFunction(IRegistry.registerRegistry.selector, "registerRegistry");
+        _authorizeTargetFunctions(_registry, GIF_ADMIN_ROLE(), functions);
+
+        // for ReleaseRegistry
         functions = new FunctionInfo[](4);
         functions[0] = toFunction(ReleaseRegistry.createNextRelease.selector, "createNextRelease");
         functions[1] = toFunction(ReleaseRegistry.activateNextRelease.selector, "activateNextRelease");
@@ -232,7 +264,10 @@ contract RegistryAdmin is
         _grantRoleToAccount(GIF_ADMIN_ROLE(), gifAdmin);
     }
     
-    function _setupGifManagerRole(address gifManager) private {
+    function _setupGifManagerRole(address gifManager)
+        private 
+        onlyInitializing()
+    {
 
         _createRole(
             GIF_MANAGER_ROLE(), 
@@ -263,7 +298,10 @@ contract RegistryAdmin is
     }
 
 
-    function _setupReleaseRegistry() private {
+    function _setupReleaseRegistry()
+        private 
+        onlyInitializing()
+    {
 
         _createTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, true, false);
 
@@ -277,16 +315,53 @@ contract RegistryAdmin is
                 name: RELEASE_REGISTRY_ROLE_NAME}));
 
         FunctionInfo[] memory functions;
-        functions = new FunctionInfo[](2);
+        functions = new FunctionInfo[](4);
         functions[0] = toFunction(RegistryAdmin.authorizeService.selector, "authorizeService");
         functions[1] = toFunction(RegistryAdmin.grantServiceRoleForAllVersions.selector, "grantServiceRoleForAllVersions");
+        functions[2] = toFunction(RegistryAdmin.grantServiceRole.selector, "grantServiceRole");
+        functions[3] = toFunction(RegistryAdmin.setServiceLocked.selector, "setServiceLocked");
         _authorizeTargetFunctions(address(this), releaseRegistryRoleId, functions);
 
         _grantRoleToAccount(releaseRegistryRoleId, _releaseRegistry);
     }
 
 
-    function _setupStaking() private {
+    function _setupRegistry()
+        internal
+        virtual
+        onlyInitializing()
+    {
+        _createTarget(_registry, REGISTRY_TARGET_NAME, true, false);
+
+        // registry function authorization for registry service
+        RoleId registryServiceRoleId = RoleIdLib.roleForTypeAndAllVersions(REGISTRY());
+        _createRole(
+            registryServiceRoleId, 
+            toRole({
+                adminRoleId: ADMIN_ROLE(),
+                roleType: RoleType.Contract,
+                maxMemberCount: MAX_NUM_RELEASES,
+                name: REGISTRY_SERVICE_ROLE_NAME}));
+
+        // authorize registry service
+        FunctionInfo[] memory functions;
+        functions = new FunctionInfo[](2);
+        functions[0] = toFunction(IRegistry.register.selector, "register");
+        functions[1] = toFunction(IRegistry.registerWithCustomType.selector, "registerWithCustomType");
+        _authorizeTargetFunctions(_registry, registryServiceRoleId, functions);
+
+        // authorize release registry
+        RoleId releaseRegistryRoleId = RoleIdLib.roleForType(RELEASE());
+        functions = new FunctionInfo[](1);
+        functions[0] = toFunction(IRegistry.registerService.selector, "registerService");
+        _authorizeTargetFunctions(_registry, releaseRegistryRoleId, functions);
+    }
+
+
+    function _setupStaking()
+        private 
+        onlyInitializing()
+    {
         _createTarget(_staking, STAKING_TARGET_NAME, true, false);
         _createTarget(_stakingStore, STAKING_STORE_TARGET_NAME, true, false);
 
@@ -359,7 +434,15 @@ contract RegistryAdmin is
         functions[12] = toFunction(StakingStore.claimUpTo.selector, "claimUpTo");
         functions[13] = toFunction(StakingStore.unstakeUpTo.selector, "unstakeUpTo");
         _authorizeTargetFunctions(_stakingStore, stakingRoleId, functions);
-
+        
         _grantRoleToAccount(stakingRoleId, _staking);
+    
+        // grant token handler authorizations
+        IStaking staking = IStaking(_staking);
+        functions = new FunctionInfo[](2);
+        functions[0] = toFunction(TokenHandler.collectTokens.selector, "collectTokens");
+        functions[1] = toFunction(TokenHandler.distributeTokens.selector, "distributeTokens");
+        
+        _authorizeTargetFunctions(address(staking.getTokenHandler()), stakingRoleId, functions);
     }
 }

package/contracts/registry/RegistryService.sol

@@ -18,8 +18,6 @@ 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);
 
@@ -39,8 +37,8 @@ contract RegistryService is
             address initialAuthority
         ) = abi.decode(data, (address, address));
 
-        initializeService(registryAddress, initialAuthority, owner);
-        registerInterface(type(IRegistryService).interfaceId);
+        _initializeService(registryAddress, initialAuthority, owner);
+        _registerInterface(type(IRegistryService).interfaceId);
     }
 
 
@@ -75,21 +73,21 @@ contract RegistryService is
         instance.linkToRegisteredNftId(); // asume safe
     }
 
-    function registerProduct(IComponent product, address owner)
-        external
-        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.nftId = getRegistry().register(info);
-    }
+    // function registerProduct(IComponent product, address owner)
+    //     external
+    //     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.nftId = getRegistry().register(info);
+    // }
 
     function registerComponent(
         IComponent component, 
@@ -111,35 +109,35 @@ contract RegistryService is
         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));
-        }
-
-        info = _getAndVerifyContractInfo(distribution, DISTRIBUTION(), owner);
-        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));
+    //     }
+
+    //     info = _getAndVerifyContractInfo(distribution, DISTRIBUTION(), owner);
+    //     info.nftId = getRegistry().register(info);
+    // }
 
     function registerDistributor(IRegistry.ObjectInfo memory info)
         external
@@ -240,8 +238,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

@@ -21,7 +21,6 @@ contract RegistryServiceManager is
         address registry, // used by implementation 
         bytes32 salt
     ) 
-        ProxyManager(registry)
     {
         if(authority == address(0)) {
             revert ErrorRegistryAccessManagerAuthorityZero();
@@ -33,7 +32,8 @@ contract RegistryServiceManager is
         
         RegistryService srv = new RegistryService{ salt: salt }();
         bytes memory data = abi.encode(registry, authority);
-        IVersionable versionable = deployDetermenistic(
+        IVersionable versionable = initialize(
+            registry,
             address(srv), 
             data,
             salt);

package/contracts/registry/ReleaseLifecycle.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.20;
 
 import {RELEASE} from "../type/ObjectType.sol";
-import {SCHEDULED, DEPLOYING, ACTIVE, PAUSED, CLOSED/*, FREE*/} from "../type/StateId.sol";
+import {SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED, CLOSED} from "../type/StateId.sol";
 import {Lifecycle} from "../shared/Lifecycle.sol";
 
 contract ReleaseLifecycle is
@@ -18,9 +18,12 @@ contract ReleaseLifecycle is
     {
         setInitialState(RELEASE(), SCHEDULED());
 
+        setStateTransition(RELEASE(), SCHEDULED(), SKIPPED());
         setStateTransition(RELEASE(), SCHEDULED(), DEPLOYING());
-        setStateTransition(RELEASE(), DEPLOYING(), DEPLOYING());
-        setStateTransition(RELEASE(), DEPLOYING(), ACTIVE());
+        setStateTransition(RELEASE(), DEPLOYING(), SKIPPED());
+        setStateTransition(RELEASE(), DEPLOYING(), DEPLOYED());
+        setStateTransition(RELEASE(), DEPLOYED(), SKIPPED());
+        setStateTransition(RELEASE(), DEPLOYED(), ACTIVE());
         setStateTransition(RELEASE(), ACTIVE(), PAUSED());
         setStateTransition(RELEASE(), PAUSED(), ACTIVE());
     }