@etherisc/gif-next 0.0.2-fe88ad7-208 → 0.0.2-ff282a4-523

package/contracts/registry/ReleaseManager.sol

@@ -3,17 +3,19 @@ pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 
-import {NftId} from "../types/NftId.sol";
-import {RoleId} from "../types/RoleId.sol";
-import {ObjectType, ObjectTypeLib, zeroObjectType, REGISTRY, SERVICE} from "../types/ObjectType.sol";
-import {VersionPart, VersionPartLib} from "../types/Version.sol";
-import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
+import {NftId} from "../type/NftId.sol";
+import {RoleId} from "../type/RoleId.sol";
+import {ObjectType, ObjectTypeLib, zeroObjectType, REGISTRY, SERVICE, STAKING} from "../type/ObjectType.sol";
+import {Version, VersionLib, VersionPart, VersionPartLib} from "../type/Version.sol";
+import {Timestamp, TimestampLib} from "../type/Timestamp.sol";
 
+import {IRegisterable} from "../shared/IRegisterable.sol";
+import {IRegistry} from "./IRegistry.sol";
+import {IRegistryService} from "./IRegistryService.sol";
 import {IService} from "../shared/IService.sol";
+import {IStaking} from "../staking/IStaking.sol";
 
-import {IRegistry} from "./IRegistry.sol";
 import {Registry} from "./Registry.sol";
-import {IRegistryService} from "./IRegistryService.sol";
 import {RegistryAccessManager} from "./RegistryAccessManager.sol";
 
 
@@ -21,28 +23,32 @@ contract ReleaseManager is AccessManaged
 {
     using ObjectTypeLib for ObjectType;
 
-    event LogReleaseCreation(VersionPart version, IService registryService); 
+    event LogReleaseCreation(VersionPart version); 
     event LogReleaseActivation(VersionPart version);
 
     // createNextRelease
     error NotRegistryService();
     error UnexpectedServiceAuthority(address expected, address found);
 
+    // register staking
+    error ErrorReleaseManagerStakingAlreadySet(address stakingAddress);
+
     // registerService
     error NotService();
-    error ServiceNotInRelease(IService service, ObjectType serviceDomain);
 
     // activateNextRelease
-    //error ReleaseNotCreated();
-    //error ReleaseRegistrationNotFinished();
+    error ReleaseNotCreated();
+    error ReleaseRegistrationNotFinished();
 
     // _getAndVerifyContractInfo
+    error ErrorReleaseManagerUnexpectedRegisterableAddress(address expected, address actual);
+    error ErrorReleaseManagerIsInterceptorTrue();
     error UnexpectedRegisterableType(ObjectType expected, ObjectType found);
-    error NotRegisterableOwner(address notOwner);
+    error NotRegisterableOwner(address expectedOwner, address actualOwner);
     error SelfRegistration();
     error RegisterableOwnerIsRegistered();
 
-    // _verifyServiceInfo
+    // _verifyService
     error UnexpectedServiceVersion(VersionPart expected, VersionPart found);
     error UnexpectedServiceDomain(ObjectType expected, ObjectType found);
     
@@ -52,24 +58,29 @@ contract ReleaseManager is AccessManaged
     error ConfigSelectorZero(uint configArrayIndex);
     error SelectorAlreadyExists(VersionPart releaseVersion, ObjectType serviceDomain);
 
-
     RegistryAccessManager private immutable _accessManager;
     IRegistry private immutable _registry;
+    IStaking private _staking;
 
-    VersionPart _latest;// latest active version
-    VersionPart immutable _initial;// first active version
+    VersionPart immutable _initial;// first active major version    
+    VersionPart _latest;// latest active major version
+    VersionPart _next;// major version to create and activate 
 
-    mapping(VersionPart version => IRegistry.ReleaseInfo info) _release;
+    mapping(VersionPart majorVersion => IRegistry.ReleaseInfo info) _release;
 
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => bytes4)) _selector; // registry service function selector assigned to domain 
+    // registry service function selector assigned to domain 
+    mapping(VersionPart majorVersion => mapping(ObjectType serviceDomain => bytes4[])) _selectors; 
 
     uint _awaitingRegistration; // "services left to register" counter
 
     mapping(address registryService => bool isActive) _active;
 
+    mapping(VersionPart majorVersion => bool isValid) _valid; // TODO refactor to use _active only
+
     constructor(
         RegistryAccessManager accessManager, 
-        VersionPart initialVersion)
+        VersionPart initialVersion
+    )
         AccessManaged(accessManager.authority())
     {
         require(initialVersion.toInt() > 0, "ReleaseManager: initial version is 0");
@@ -77,46 +88,103 @@ contract ReleaseManager is AccessManaged
         _accessManager = accessManager;
 
         _initial = initialVersion;
-
+        _next = initialVersion;
         _registry = new Registry();
     }
 
-    // TODO deploy proxy and initialize with given implementation instead of using given proxy?
-    // IMPORTANT: MUST never be possible to create with access/release manager, token registry
-    function createNextRelease(IRegistryService service)
+    function registerStaking(
+        address stakingAddress,
+        address stakingOwner
+    )
         external
         restricted // GIF_ADMIN_ROLE
         returns(NftId nftId)
+    {
+        // verify staking contract
+        _getAndVerifyContractInfo(stakingAddress, STAKING(), stakingOwner);
+        _staking = IStaking(stakingAddress);
+
+        nftId = _registry.registerStaking(
+            stakingAddress,
+            stakingOwner);
+
+        _staking.linkToRegisteredNftId();
+    }
+
+    /// @dev skips previous release if was not activated
+    function createNextRelease()
+        external
+        restricted // GIF_ADMIN_ROLE
+    {
+        // allow to register new registry service for next version
+        // TODO check/test: assignment to _next likely missing ...
+        VersionPartLib.toVersionPart(_next.toInt() + 1);
+
+        // disallow registration of regular services for next version while registry service is not registered 
+        _awaitingRegistration = 0;
+
+        emit LogReleaseCreation(_next); 
+    }
+
+    function activateNextRelease() 
+        external 
+        restricted // GIF_ADMIN_ROLE
+    {
+        VersionPart version = _next;
+        address service = _registry.getServiceAddress(REGISTRY(), version);
+
+        // release was created
+        if(service == address(0)) {
+            revert ReleaseNotCreated();
+        }
+
+        // release fully deployed
+        if(_awaitingRegistration > 0) {
+            revert ReleaseRegistrationNotFinished();
+        }
+
+        //setTargetClosed(service, false);
+
+        _latest = version;
+
+        _active[service] = true;
+        _valid[version] = true;
+
+        emit LogReleaseActivation(version);
+    }
+
+    // TODO implement reliable way this function can only be called directly after createNextRelease()
+    // IMPORTANT: MUST never be possible to create with access/release manager, token registry
+    // callable once per release after release creation
+    // can not register regular services
+    function registerRegistryService(IRegistryService service)
+        external
+        restricted // GIF_MANAGER_ROLE
+        returns(NftId nftId)
     {
         if(!service.supportsInterface(type(IRegistryService).interfaceId)) {
             revert NotRegistryService();
         }
+
         // TODO unreliable! MUST guarantee the same authority -> how?
-        if(service.authority() != authority()) {
+        address serviceAuthority = service.authority();
+        if(serviceAuthority != authority()) {
             revert UnexpectedServiceAuthority(
                 authority(), 
-                service.authority()); 
+                serviceAuthority); 
         }
 
-        (
-            IRegistry.ObjectInfo memory info, 
-            bytes memory data
-        ) = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
+        IRegistry.ObjectInfo memory info = _getAndVerifyContractInfo(address(service), SERVICE(), msg.sender);
 
-        VersionPart version = getNextVersion();
+        VersionPart majorVersion = _next;
         ObjectType domain = REGISTRY();
-        _verifyServiceInfo(info, version, domain);
-
-        _createRelease(data);
-
-        //setTargetClosed(service, true);
+        _verifyService(service, majorVersion, domain);
+        _createRelease(service.getFunctionConfigs());
         
-        nftId = _registry.registerService(info, version, domain);
+        nftId = _registry.registerService(info, majorVersion, domain);
 
         // external call
         service.linkToRegisteredNftId();
-
-        emit LogReleaseCreation(version, service); 
     }
 
     // TODO adding service to release -> synchronized with proxy upgrades or simple addServiceToRelease(service, version, selector)?
@@ -130,70 +198,29 @@ contract ReleaseManager is AccessManaged
             revert NotService();
         }
 
-        (
-            IRegistry.ObjectInfo memory info, 
-            //bytes memory data
-        ) = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
-
-        VersionPart version = getNextVersion();
-        ObjectType domain = _verifyServiceInfo(info, version, zeroObjectType());
-
-        bytes4[] memory selector = new bytes4[](1);
-        selector[0] = _selector[version][domain];
-
-        // service type is in release
-        if(selector[0] == 0) {
-            revert ServiceNotInRelease(service, domain);
+        IRegistry.ObjectInfo memory info = _getAndVerifyContractInfo(address(service), SERVICE(), msg.sender);
+        VersionPart majorVersion = getNextVersion();
+        ObjectType domain = _release[majorVersion].domains[_awaitingRegistration];// reversed registration order of services specified in RegistryService config
+        _verifyService(service, majorVersion, domain);
+
+        // setup and grant unique role if service does registrations
+        bytes4[] memory selectors = _selectors[majorVersion][domain];
+        address registryService = _registry.getServiceAddress(REGISTRY(), majorVersion);
+        if(selectors.length > 0) {
+            _accessManager.setAndGrantUniqueRole(
+                address(service), 
+                registryService, 
+                selectors);
         }
-
-        // setup and grant unique role
-        address registryService = _registry.getServiceAddress(REGISTRY(), version);
-        _accessManager.setAndGrantUniqueRole(
-            address(service), 
-            registryService, 
-            selector);
-
+        
         _awaitingRegistration--;
 
-        // activate release
-        if(_awaitingRegistration == 0) {
-            _latest = version;
-            _active[registryService] = true;  
-
-            emit LogReleaseActivation(version);
-        }
-
-        nftId = _registry.registerService(info, version, domain);
+        nftId = _registry.registerService(info, majorVersion, domain);
 
         // external call
         service.linkToRegisteredNftId(); 
     }
 
-    /*function activateNextRelease() 
-        external 
-        restricted // GIF_ADMIN_ROLE
-    {
-        VersionPart version = getNextVersion();
-        address service = _registry.getServiceAddress(REGISTRY(), version);
-
-        // release was created
-        if(service == address(0)) {
-            revert ReleaseNotCreated();
-        }
-
-        // release fully deployed
-        if(_awaitingRegistration > 0) {
-            revert ReleaseRegistrationNotFinished();
-        }
-
-        //setTargetClosed(service, false);
-
-        _latest = version;
-        _active[service] = true;
-
-        LogReleaseActivation(version);
-    }*/
-
     //--- view functions ----------------------------------------------------//
 
     function isActiveRegistryService(address service) external view returns(bool)
@@ -201,9 +228,14 @@ contract ReleaseManager is AccessManaged
         return _active[service];
     }
 
-    function getRegistry() external view returns(address)
+    function isValidRelease(VersionPart version) external view returns(bool)
+    {
+        return _valid[version];
+    }
+
+    function getRegistryAddress() external view returns(address)
     {
-        return (address(_registry));
+        return address(_registry);
     }
 
     function getReleaseInfo(VersionPart version) external view returns(IRegistry.ReleaseInfo memory)
@@ -213,11 +245,7 @@ contract ReleaseManager is AccessManaged
 
     function getNextVersion() public view returns(VersionPart) 
     {
-        uint256 latest = _latest.toInt();
-
-        return latest == 0 ?
-            _initial : // no active releases yet
-            VersionPartLib.toVersionPart(latest + 1);
+        return _next;
     }
 
     function getLatestVersion() external view returns(VersionPart) {
@@ -231,20 +259,25 @@ contract ReleaseManager is AccessManaged
     //--- private functions ----------------------------------------------------//
 
     function _getAndVerifyContractInfo(
-        IService service,
+        address registerableAddress,
         ObjectType expectedType,
         address expectedOwner // assume always valid, can not be 0
     )
         internal
-        view
+        // view
         returns(
-            IRegistry.ObjectInfo memory info, 
-            bytes memory data
+            IRegistry.ObjectInfo memory info
         )
     {
-        (info, data) = service.getInitialInfo();
-        info.objectAddress = address(service);
-        info.isInterceptor = false; // service is never interceptor, at least now
+        info = IRegisterable(registerableAddress).getInitialInfo();
+
+        if(info.objectAddress != registerableAddress) {
+            revert ErrorReleaseManagerUnexpectedRegisterableAddress(registerableAddress, info.objectAddress);
+        }
+
+        if(info.isInterceptor) {
+            revert ErrorReleaseManagerIsInterceptorTrue();
+        }
 
         if(info.objectType != expectedType) {// type is checked in registry anyway...but service logic may depend on expected value
             revert UnexpectedRegisterableType(expectedType, info.objectType);
@@ -253,33 +286,20 @@ contract ReleaseManager is AccessManaged
         address owner = info.initialOwner;
 
         if(owner != expectedOwner) { // registerable owner protection
-            revert NotRegisterableOwner(expectedOwner); 
+            revert NotRegisterableOwner(expectedOwner, owner); 
         }
 
-        if(owner == address(service)) {
+        if(owner == address(registerableAddress)) {
             revert SelfRegistration();
         }
-
-        /*if(owner == address(0)) { // never 0
-            revert();// RegisterableOwnerIsZero();
-        }*/
         
         if(_registry.isRegistered(owner)) { 
             revert RegisterableOwnerIsRegistered(); 
         }
-
-        /*NftId parentNftId = info.parentNftId;
-        IRegistry.ObjectInfo memory parentInfo = getRegistry().getObjectInfo(parentNftId);
-
-        if(parentInfo.objectType != parentType) { // parent registration + type
-            revert InvalidParent(parentNftId);
-        }*/
-
-        return(info, data);
     }
 
-    function _verifyServiceInfo(
-        IRegistry.ObjectInfo memory info,
+    function _verifyService(
+        IService service,
         VersionPart expectedVersion,
         ObjectType expectedDomain
     )
@@ -287,30 +307,24 @@ contract ReleaseManager is AccessManaged
         view
         returns(ObjectType)
     {
-        (
-            ObjectType domain,
-            VersionPart version
-        ) = abi.decode(info.data, (ObjectType, VersionPart));
-
-        if(version != expectedVersion) {
-            revert UnexpectedServiceVersion(expectedVersion, version);
+        Version version = service.getVersion();
+        VersionPart majorVersion = version.toMajorPart();
+        if(majorVersion != expectedVersion) {
+            revert UnexpectedServiceVersion(expectedVersion, majorVersion);
         }
 
-        if(expectedDomain.gtz()) { 
-            if(domain != expectedDomain) {
-                revert UnexpectedServiceDomain(expectedDomain, domain);
-            }
+        if(service.getDomain() != expectedDomain) {
+            revert UnexpectedServiceDomain(expectedDomain, service.getDomain());
         }
 
-        return domain;
+        return expectedDomain;
     }
 
     // TODO check if registry supports types specified in the config array
-    function _createRelease(bytes memory configBytes)
+    function _createRelease(IRegistryService.FunctionConfig[] memory config)
         internal
     {
         VersionPart version = getNextVersion();
-        IRegistryService.FunctionConfig[] memory config = abi.decode(configBytes, (IRegistryService.FunctionConfig[]));
 
         if(config.length == 0) {
             revert ConfigMissing();
@@ -320,23 +334,21 @@ contract ReleaseManager is AccessManaged
         for(uint idx = 0; idx < config.length; idx++)
         {
             ObjectType domain = config[idx].serviceDomain;
-            bytes4 selector = config[idx].selector;
-
             // not "registry service" / zero domain
             if(
                 domain == REGISTRY() ||
                 domain.eqz()
             ) { revert ConfigServiceDomainInvalid(idx, domain); } 
 
-            // selector not zero
-            if(selector == 0) { revert ConfigSelectorZero(idx); }
+            bytes4[] memory selectors = config[idx].selectors;
 
+            // TODO can be zero -> e.g. duplicate domain, first with zero selector, second with non zero selector -> need to check _release[version].domains.contains(domain) instead
             // no overwrite
-            if(_selector[version][domain] > 0) {
+            if(_selectors[version][domain].length > 0) {
                 revert SelectorAlreadyExists(version, domain); 
             }
             
-            _selector[version][domain] = selector;
+            _selectors[version][domain] = selectors;
             _release[version].domains.push(domain);
         }
         // TODO set when activated?

package/contracts/registry/TokenRegistry.sol

@@ -6,8 +6,8 @@ import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165C
 
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IRegistry} from "./IRegistry.sol";
-import {VersionPart} from "../types/Version.sol";
-import {REGISTRY} from "../types/ObjectType.sol";
+import {VersionPart} from "../type/Version.sol";
+import {REGISTRY} from "../type/ObjectType.sol";
 import {NftOwnable} from "../shared/NftOwnable.sol";
 
 /// @title contract to register token per GIF major release.
@@ -26,21 +26,32 @@ contract TokenRegistry is
     mapping(address token => bool registered) internal _registered;
     mapping(address token => mapping(VersionPart majorVersion => bool isActive)) internal _active;
 
-    constructor()
-        NftOwnable()
-    { }
+    constructor(
+        address registry
+    )
+    { 
+        initialize(registry);
+    }
+
+    function initialize(address registry)
+        public
+        initializer()
+    {
+        initializeNftOwnable(msg.sender, registry);
+    }
 
 
     /// @dev link ownership of token registry to nft owner of registry service
+    // TODO latter registry service will get new release, new address, new nft, TokenRegistry will not catch that -> use AccessManaged only for services
     function linkToNftOwnable(address registryAddress) 
         external
         onlyOwner
     {
         IRegistry registry = IRegistry(registryAddress);
-        // TODO use _latest instead of `next version` -> but _latest is 0 before first release activation
-        address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getMajorVersionMax());
+        // TODO use _latest instead of _initial -> but _latest is 0 before first release activation
+        address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getNextVersion());
 
-        _linkToNftOwnable(registryAddress, registryServiceAddress);
+        _linkToNftOwnable(registryServiceAddress);
     }
 
     /// @dev token state is informative, registry have no clue about used tokens
@@ -58,7 +69,7 @@ contract TokenRegistry is
         // verify valid major version
         // ensure major version increments is one
         uint256 version = majorVersion.toInt();
-        if (version < _registry.getMajorVersionMin().toInt() || version > _registry.getMajorVersionMax().toInt()) {
+        if (!getRegistry().isValidRelease(majorVersion)) {
             revert TokenMajorVersionInvalid(majorVersion);
         }
 
@@ -91,12 +102,7 @@ contract TokenRegistry is
             revert NotContract(token);
         }
 
-        // MUST not be GIF registerable
-        if(ERC165Checker.supportsInterface(token, type(IRegisterable).interfaceId)) {
-            revert NotToken(token);
-        }
-
-        // MUST have decimals > 0
+        // MUST have decimals > 0 (indicator that this is in fact an erc20 token)
         IERC20Metadata erc20 = IERC20Metadata(token);
         if(erc20.decimals() == 0) {
             revert TokenDecimalsZero();

package/contracts/shared/AccessManagerUpgradeableInitializeable.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {AccessManagerUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagerUpgradeable.sol";
+
+
+contract AccessManagerUpgradeableInitializeable is AccessManagerUpgradeable {
+
+    function initialize(address initialAdmin) initializer public {
+        __AccessManager_init(initialAdmin);        
+    }
+
+}