@etherisc/gif-next 0.0.2-bdb55c6-577 → 0.0.2-bdbfee9-660

package/contracts/registry/RegistryService.sol

@@ -1,47 +1,26 @@
 // 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);
 
-    // From IService
-    function getDomain() public pure override returns(ObjectType serviceDomain) {
-        return REGISTRY(); 
-    }
-
     // from Versionable
 
     /// @dev top level initializer
@@ -51,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);
     }
 
 
@@ -79,7 +58,7 @@ contract RegistryService is
     function registerInstance(IRegisterable instance, address owner)
         external
         virtual
-        restricted
+        restricted()
         returns(
             IRegistry.ObjectInfo memory info
         ) 
@@ -94,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
         ) 
@@ -126,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());
@@ -171,7 +129,8 @@ contract RegistryService is
 
     function registerPolicy(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, POLICY());
@@ -180,7 +139,8 @@ contract RegistryService is
 
     function registerBundle(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, BUNDLE());
@@ -189,7 +149,8 @@ contract RegistryService is
 
     function registerStake(IRegistry.ObjectInfo memory info)
         external
-        restricted 
+        virtual
+        restricted()
         returns(NftId nftId) 
     {
         _verifyObjectInfo(info, STAKE());
@@ -204,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 
@@ -243,6 +205,7 @@ contract RegistryService is
         ObjectType expectedType
     )
         internal
+        virtual
         view
     {
         if(info.objectAddress > address(0)) {
@@ -259,8 +222,20 @@ 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);
+            }
         }
     }
+
+    // From IService
+    function _getDomain() internal override pure returns(ObjectType serviceDomain) {
+        return REGISTRY(); 
+    }
 }

package/contracts/registry/RegistryServiceManager.sol

@@ -1,14 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
-
-import {Registry} from "./Registry.sol";
-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";
-import {TokenRegistry} from "./TokenRegistry.sol";
-
 
 contract RegistryServiceManager is
     ProxyManager
@@ -26,7 +21,6 @@ contract RegistryServiceManager is
         address registry, // used by implementation 
         bytes32 salt
     ) 
-        ProxyManager(registry)
     {
         if(authority == address(0)) {
             revert ErrorRegistryAccessManagerAuthorityZero();
@@ -37,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);

package/contracts/registry/ReleaseAdmin.sol

@@ -0,0 +1,195 @@
+// 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);
+
+        // 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);
+
+        _createUncheckedTarget(address(service), serviceTargetName, TargetType.Service);
+    }
+
+    //--- private initialization functions -------------------------------------------//
+
+    function _setupReleaseRegistry(address releaseRegistry)
+        private 
+        onlyInitializing()
+    {
+        _createManagedTarget(address(this), RELEASE_ADMIN_TARGET_NAME, IAccess.TargetType.Core);
+
+        _createRole(
+            RELEASE_REGISTRY_ROLE(), 
+            AccessAdminLib.toRole({
+                adminRoleId: ADMIN_ROLE(),
+                roleType: RoleType.Contract,
+                maxMemberCount: 1,
+                name: RELEASE_REGISTRY_ROLE_NAME}));
+
+        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, true);
+
+        _grantRoleToAccount(RELEASE_REGISTRY_ROLE(), releaseRegistry);
+    }
+}

package/contracts/registry/ReleaseLifecycle.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+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
+{
+    constructor() {
+        _setupLifecycle();
+    }
+
+    function _setupLifecycle()
+        internal 
+        override
+    {
+        setInitialState(RELEASE(), SCHEDULED());
+
+        setStateTransition(RELEASE(), SCHEDULED(), SKIPPED());
+        setStateTransition(RELEASE(), SCHEDULED(), DEPLOYING());
+        setStateTransition(RELEASE(), DEPLOYING(), SKIPPED());
+        setStateTransition(RELEASE(), DEPLOYING(), DEPLOYED());
+        setStateTransition(RELEASE(), DEPLOYED(), SKIPPED());
+        setStateTransition(RELEASE(), DEPLOYED(), ACTIVE());
+        setStateTransition(RELEASE(), ACTIVE(), PAUSED());
+        setStateTransition(RELEASE(), PAUSED(), ACTIVE());
+    }
+}