@etherisc/gif-next 0.0.2-f12cf4d-104 → 0.0.2-f13d67f-541

package/contracts/registry/RegistryAuthorization.sol

@@ -0,0 +1,337 @@
+// 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 {AccessAdminLib} from "../authorization/AccessAdminLib.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, 
+               TargetType.Core,
+               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()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    REGISTRY_SERVICE_ROLE_NAME));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(STAKING()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    STAKING_SERVICE_ROLE_NAME));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(COMPONENT()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    COMPONENT_SERVICE_ROLE_NAME));
+
+          _addRole(
+               RoleIdLib.toGenericServiceRoleId(POOL()), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Core,
+                    maxReleases, 
+                    POOL_SERVICE_ROLE_NAME));
+
+          // gif admin role
+          _addRole(
+               GIF_ADMIN_ROLE(),
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Custom, // custom is only type that allows role removal
+                    2, // TODO decide on max member count
+                    GIF_ADMIN_ROLE_NAME));
+
+          // gif manager role
+          _addRole(
+               GIF_MANAGER_ROLE(), 
+               AccessAdminLib.roleInfo(
+                    ADMIN_ROLE(),
+                    TargetType.Custom, // custom is only type that allows role removal
+                    1, // TODO decide on max member count
+                    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

@@ -30,14 +30,14 @@ 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);
+        __Service_init(authority, registry, owner);
         _registerInterface(type(IRegistryService).interfaceId);
     }
 

package/contracts/registry/RegistryServiceManager.sol

@@ -31,7 +31,7 @@ contract RegistryServiceManager is
         }
         
         RegistryService srv = new RegistryService{ salt: salt }();
-        bytes memory data = abi.encode(registry, authority);
+        bytes memory data = abi.encode(authority, registry);
         IVersionable versionable = initialize(
             registry,
             address(srv), 

package/contracts/registry/ReleaseAdmin.sol

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IAccess} from "../authorization/IAccess.sol";
+import {IAuthorization} from "../authorization/IAuthorization.sol";
+import {IService} from "../shared/IService.sol";
+import {IServiceAuthorization} from "../authorization/IServiceAuthorization.sol";
+
+import {AccessAdmin} from "../authorization/AccessAdmin.sol";
+import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
+import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
+import {ObjectType, ObjectTypeLib, RELEASE} from "../type/ObjectType.sol";
+import {RoleId, ADMIN_ROLE, RELEASE_REGISTRY_ROLE} from "../type/RoleId.sol";
+import {Str} from "../type/String.sol";
+import {VersionPart} from "../type/Version.sol";
+
+
+/// @dev The ReleaseAdmin contract implements the central authorization for the services of a specific release.
+/// There is one ReleaseAdmin contract per major GIF release.
+/// Locking/unlocking of all services of a release is implemented in function setReleaseLocked.
+contract ReleaseAdmin is
+    AccessAdmin
+{
+    event LogReleaseAdminReleaseLockChanged(VersionPart release, bool locked);
+    event LogReleaseAdminServiceLockChanged(VersionPart release, address service, bool locked);
+
+    error ErrorReleaseAdminCallerNotReleaseRegistry(address caller);
+    error ErrorReleaseAdminNotService(address notService);
+    error ErrorReleaseAdminReleaseLockAlreadySetTo(bool locked);
+
+    /// @dev release core roles
+    string public constant RELEASE_REGISTRY_ROLE_NAME = "ReleaseRegistry_Role";
+
+    /// @dev release core targets
+    string public constant RELEASE_ADMIN_TARGET_NAME = "ReleaseAdmin";
+
+    IServiceAuthorization internal _serviceAuthorization;
+
+
+    modifier onlyReleaseRegistry() {
+        (bool isMember, ) = _authority.hasRole(RELEASE_REGISTRY_ROLE().toInt(), msg.sender);
+        if(!isMember) {
+            revert ErrorReleaseAdminCallerNotReleaseRegistry(msg.sender);
+        }
+        _;
+    }
+
+
+    // @dev Only used for master release admin
+    constructor(address accessManager) {
+        initialize(
+            accessManager,
+            "MasterReleaseAdmin");
+    }
+
+
+    function completeSetup(
+        address registry,
+        address authorization,
+        VersionPart release,
+        address releaseRegistry
+    )
+        external
+        reinitializer(uint64(release.toInt()))
+    {
+        // checks
+        AccessAdminLib.checkRegistry(registry);
+
+        AccessManagerCloneable(
+            authority()).completeSetup(
+                registry, 
+                release);
+
+        IServiceAuthorization serviceAuthorization = IServiceAuthorization(authorization);
+        _checkAuthorization(address(serviceAuthorization), RELEASE(), release, true, true);
+        _serviceAuthorization = serviceAuthorization;
+
+        // link nft ownability to registry
+        _linkToNftOwnable(registry);
+
+        _createRoles(_serviceAuthorization);
+
+        // setup release contract
+        _setupReleaseRegistry(releaseRegistry);
+
+        // relase services will be authorized one by one via authorizeService()
+    }
+
+
+    /// @dev Sets up authorizaion for specified service.
+    /// For all authorized services its authorized functions are enabled.
+    /// Permissioned function: Access is restricted to release registry.
+    function authorizeService(
+        IService service,
+        ObjectType serviceDomain,
+        VersionPart release
+    )
+        external
+        restricted()
+    {
+        _createServiceTargetAndRole(service, serviceDomain, release);
+
+        // authorize functions of service
+        Str serviceTarget = _serviceAuthorization.getServiceTarget(serviceDomain);
+        RoleId[] memory authorizedRoles = _serviceAuthorization.getAuthorizedRoles(serviceTarget);
+
+        for (uint256 i = 0; i < authorizedRoles.length; i++) {
+            _authorizeFunctions(
+                IAuthorization(address(_serviceAuthorization)), 
+                serviceTarget, 
+                authorizedRoles[i]);
+        }
+    }
+
+
+    /// @dev Locks/unlocks all release targets.
+    /// For all authorized services of release its authorized functions are disabled/enabled.
+    /// Permissioned function: Access is restricted to release registry.
+    /// Note: onlyReleaseRegistry() modifier is used to prevent dead lock.
+    function setReleaseLocked(bool locked)
+        external
+        onlyReleaseRegistry()
+    {
+        // checks
+        AccessManagerCloneable accessManager = AccessManagerCloneable(authority());
+        if(accessManager.isLocked() == locked) {
+            revert ErrorReleaseAdminReleaseLockAlreadySetTo(locked);
+        }
+
+        // effects
+        accessManager.setLocked(locked);
+
+        emit LogReleaseAdminReleaseLockChanged(getRelease(), locked);
+    }
+
+
+    /// @dev Lock/unlock specific service of release.
+    /// Permissioned function: Access is restricted to release registry.
+    function setServiceLocked(IService service, bool locked)
+        external
+        restricted()
+    {
+        // assume all targets except release admin are services
+        // ensure release admin can not be locked
+        if(address(service) == address(this)) {
+            revert ErrorReleaseAdminNotService(address(service));
+        }
+
+        _setTargetLocked(address(service), locked);
+
+        emit LogReleaseAdminServiceLockChanged(service.getRelease(), address(service), locked);
+    }
+
+    //--- private functions -------------------------------------------------//
+
+    function _createServiceTargetAndRole(
+        IService service, 
+        ObjectType serviceDomain, 
+        VersionPart release
+    )
+        private
+    {
+        string memory baseName = ObjectTypeLib.toName(serviceDomain);
+
+        // create service target
+        string memory serviceTargetName = ObjectTypeLib.toVersionedName(
+            baseName, "Service", release);
+
+        // create unchecked target
+        _createTarget(address(service), serviceTargetName, TargetType.Service, false);
+    }
+
+    //--- private initialization functions -------------------------------------------//
+
+    function _setupReleaseRegistry(address releaseRegistry)
+        private 
+        onlyInitializing()
+    {
+
+        _createRole(
+            RELEASE_REGISTRY_ROLE(), 
+            AccessAdminLib.coreRoleInfo(RELEASE_REGISTRY_ROLE_NAME),
+            true); // revets on existing role
+
+        _createTarget(
+            address(this), 
+            RELEASE_ADMIN_TARGET_NAME,
+            IAccess.TargetType.Core, 
+            true); // check authority maches
+
+        FunctionInfo[] memory functions;
+        functions = new FunctionInfo[](2);
+        functions[0] = AccessAdminLib.toFunction(ReleaseAdmin.authorizeService.selector, "authorizeService");
+        functions[1] = AccessAdminLib.toFunction(ReleaseAdmin.setServiceLocked.selector, "setServiceLocked");
+        _authorizeTargetFunctions(address(this), RELEASE_REGISTRY_ROLE(), functions, false, true);
+
+        _grantRoleToAccount(RELEASE_REGISTRY_ROLE(), releaseRegistry);
+    }
+}

package/contracts/registry/ReleaseLifecycle.sol

@@ -5,6 +5,8 @@ import {RELEASE} from "../type/ObjectType.sol";
 import {SCHEDULED, DEPLOYING, DEPLOYED, SKIPPED, ACTIVE, PAUSED, CLOSED} from "../type/StateId.sol";
 import {Lifecycle} from "../shared/Lifecycle.sol";
 
+/// @dev Release lifeycle state machine.
+/// Helper contract for ReleaseRegistry.
 contract ReleaseLifecycle is
     Lifecycle
 {