@etherisc/gif-next 0.0.2-b3a9c97-695 → 0.0.2-b3e9a44-364

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,46 @@ 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 revokeServiceRole(
+        IService service,
+        ObjectType domain, 
+        VersionPart version
+    )
+        external
+        restricted()
+    {
+        _revokeRoleFromAccount(
+            RoleIdLib.roleForTypeAndVersion(
+                domain, 
+                version), 
+            address(service));
+    }
 
     function grantServiceRoleForAllVersions(IService service, ObjectType domain)
         external
@@ -112,14 +139,44 @@ contract RegistryAdmin is
             address(service)); 
     }
 
+    function revokeServiceRoleForAllVersions(IService service, ObjectType domain)
+        external
+        restricted()
+    {
+        _revokeRoleFromAccount(
+            RoleIdLib.roleForTypeAndAllVersions(domain), 
+            address(service));
+    }
 
-    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(
@@ -134,7 +191,7 @@ contract RegistryAdmin is
         // create service role
         RoleId serviceRoleId = RoleIdLib.roleForTypeAndVersion(
             serviceDomain, 
-            version);
+            releaseVersion);
 
         _createRole(
             serviceRoleId, 
@@ -155,15 +212,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 +232,7 @@ contract RegistryAdmin is
             } else {
                 authorizedRoleId = RoleIdLib.roleForTypeAndVersion(
                 authorizedDomain, 
-                release);
+                releaseVersion);
             }
 
             // get authorized functions for authorized domain
@@ -190,27 +247,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 functions -------------------------------------------------//
+    //--- private initialization functions -------------------------------------------//
 
-    function _setupGifAdminRole(address gifAdmin) private {
+    function _setupGifAdminRole(address gifAdmin) 
+        private 
+        onlyInitializing()
+    {
         
         _createRole(
             GIF_ADMIN_ROLE(), 
@@ -220,8 +262,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 +279,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 +313,10 @@ contract RegistryAdmin is
     }
 
 
-    function _setupReleaseRegistry() private {
+    function _setupReleaseRegistry()
+        private 
+        onlyInitializing()
+    {
 
         _createTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, true, false);
 
@@ -277,16 +330,54 @@ contract RegistryAdmin is
                 name: RELEASE_REGISTRY_ROLE_NAME}));
 
         FunctionInfo[] memory functions;
-        functions = new FunctionInfo[](2);
+        functions = new FunctionInfo[](5);
         functions[0] = toFunction(RegistryAdmin.authorizeService.selector, "authorizeService");
         functions[1] = toFunction(RegistryAdmin.grantServiceRoleForAllVersions.selector, "grantServiceRoleForAllVersions");
+        functions[2] = toFunction(RegistryAdmin.revokeServiceRoleForAllVersions.selector, "revokeServiceRoleForAllVersions");
+        functions[3] = toFunction(RegistryAdmin.grantServiceRole.selector, "grantServiceRole");
+        functions[4] = toFunction(RegistryAdmin.revokeServiceRole.selector, "revokeServiceRole");
         _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 +450,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

@@ -39,8 +39,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 +75,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 +111,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 +240,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/ReleaseRegistry.sol

@@ -194,7 +194,6 @@ contract ReleaseRegistry is
         emit LogReleaseCreation(version, releaseSalt);
     }
 
-    // TODO this function can have 0 args -> use stored addresses from prepareNextRelease()
     function registerService(IService service) 
         external
         restricted // GIF_MANAGER_ROLE
@@ -230,19 +229,26 @@ contract ReleaseRegistry is
         }
 
         // register service with registry
+        // !!! TODO MUST call registry at the end of this function
         nftId = _registry.registerService(info, serviceVersion, serviceDomain);
         service.linkToRegisteredNftId();
         _registeredServices++;
 
         // setup service authorization
+        // !!! TODO service A can call service B while release is not active
         _admin.authorizeService(
             _serviceAuthorization[releaseVersion], 
-            service);
+            service,
+            serviceDomain,
+            serviceVersion);
 
-        // TODO consider to extend this to REGISTRY
         // special roles for registry/staking/pool service
-        if (serviceDomain == STAKING() || serviceDomain == POOL()) {
-            // TODO rename to grantServiceDomainRole()
+        // !!! TODO registry service allowed to call registry while release is not activated (same for staking/pool service and staking)
+        if (
+            serviceDomain == REGISTRY() ||
+            serviceDomain == STAKING() ||
+            serviceDomain == POOL()) 
+        {
             _admin.grantServiceRoleForAllVersions(service, serviceDomain);
         }
     }
@@ -475,7 +481,7 @@ contract ReleaseRegistry is
         // TODO try catch and return false in case of revert
         // or just panic
         // check if contract returns a zero nft id for its own address
-        if (IRegistry(registryAddress).getNftId(registryAddress).eqz()) {
+        if (IRegistry(registryAddress).getNftIdForAddress(registryAddress).eqz()) {
             return false;
         }
 

package/contracts/registry/ServiceAuthorizationV3.sol

@@ -2,14 +2,12 @@
 pragma solidity ^0.8.20;
 
 import {
-     ALL, REGISTRY, SERVICE, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKE, STAKING, PRICE
+     ALL, REGISTRY, PRODUCT, ORACLE, POOL, INSTANCE, COMPONENT, DISTRIBUTION, DISTRIBUTOR, APPLICATION, POLICY, CLAIM, BUNDLE, STAKING, PRICE
 } from "../../contracts/type/ObjectType.sol";
 
-import {ComponentService} from "../shared/ComponentService.sol";
 import {IAccess} from "../authorization/IAccess.sol";
 import {IBundleService} from "../pool/IBundleService.sol";
 import {IDistributionService} from "../distribution/IDistributionService.sol";
-import {InstanceService} from "../instance/InstanceService.sol";
 import {IInstanceService} from "../instance/IInstanceService.sol";
 import {IPoolService} from "../pool/IPoolService.sol";
 import {IStakingService} from "../staking/IStakingService.sol";
@@ -39,9 +37,9 @@ contract ServiceAuthorizationV3
           _authorizeDomain(POOL(), address(8));
           _authorizeDomain(ORACLE(), address(9));
           _authorizeDomain(PRODUCT(), address(10));
-          _authorizeDomain(CLAIM(), address(11));
-          _authorizeDomain(APPLICATION(), address(12));
-          _authorizeDomain(POLICY(), address(13));
+          _authorizeDomain(POLICY(), address(11));
+          _authorizeDomain(CLAIM(), address(12));
+          _authorizeDomain(APPLICATION(), address(13));
      }
 
 
@@ -163,6 +161,7 @@ contract ServiceAuthorizationV3
 
           functions = _authorizeForService(DISTRIBUTION(), POLICY());
           _authorize(functions, IDistributionService.processSale.selector, "processSale");
+          _authorize(functions, IDistributionService.processReferral.selector, "processReferral");
      }
 
 
@@ -175,11 +174,10 @@ contract ServiceAuthorizationV3
           functions = _authorizeForService(POOL(), POLICY());
           _authorize(functions, IPoolService.lockCollateral.selector, "lockCollateral");
           _authorize(functions, IPoolService.releaseCollateral.selector, "releaseCollateral");
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
           _authorize(functions, IPoolService.processSale.selector, "processSale");
 
           functions = _authorizeForService(POOL(), CLAIM());
-          _authorize(functions, IPoolService.reduceCollateral.selector, "reduceCollateral");
+          _authorize(functions, IPoolService.processPayout.selector, "processPayout");
      }