@etherisc/gif-next 0.0.2-9d3eab3-323 → 0.0.2-9dc4419-573

package/contracts/registry/ReleaseManager.sol

@@ -2,29 +2,26 @@
 pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
-import {AccessManager} from "@openzeppelin/contracts/access/manager/AccessManager.sol";
 
 import {NftId} from "../types/NftId.sol";
 import {RoleId} from "../types/RoleId.sol";
-import {ObjectType, zeroObjectType, SERVICE} from "../types/ObjectType.sol";
-import {VersionPart, VersionPartLib} from "../types/Version.sol";
+import {ObjectType, ObjectTypeLib, zeroObjectType, REGISTRY, SERVICE} from "../types/ObjectType.sol";
+import {Version, VersionLib, VersionPart, VersionPartLib} from "../types/Version.sol";
+import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
 
-import {IVersionable} from "../shared/IVersionable.sol";
 import {IService} from "../shared/IService.sol";
-import {ProxyManager} from "../shared/ProxyManager.sol";
 
 import {IRegistry} from "./IRegistry.sol";
 import {Registry} from "./Registry.sol";
 import {IRegistryService} from "./IRegistryService.sol";
-import {RegistryService} from "./RegistryService.sol";
-import {RegistryServiceManager} from "./RegistryServiceManager.sol";
 import {RegistryAccessManager} from "./RegistryAccessManager.sol";
 
 
 contract ReleaseManager is AccessManaged
 {
-    event LogReleaseCreation(VersionPart version, IService registryService); 
-    event LogServiceRegistration(VersionPart majorVersion, ObjectType serviceDomain); 
+    using ObjectTypeLib for ObjectType;
+
+    event LogReleaseCreation(VersionPart version); 
     event LogReleaseActivation(VersionPart version);
 
     // createNextRelease
@@ -33,210 +30,192 @@ contract ReleaseManager is AccessManaged
 
     // registerService
     error NotService();
-    error ServiceNotInRelease(IService service, ObjectType serviceDomain);
-    error ServiceAlreadyRegistered(address service);
 
     // activateNextRelease
-    //error ReleaseNotCreated();
-    //error ReleaseRegistrationNotFinished();
+    error ReleaseNotCreated();
+    error ReleaseRegistrationNotFinished();
 
     // _getAndVerifyContractInfo
     error UnexpectedRegisterableType(ObjectType expected, ObjectType found);
-    error NotRegisterableOwner(address expectedOwner);
+    error NotRegisterableOwner(address notOwner);
     error SelfRegistration();
     error RegisterableOwnerIsRegistered();
 
-    // _verifyServiceInfo
+    // _verifyService
     error UnexpectedServiceVersion(VersionPart expected, VersionPart found);
     error UnexpectedServiceDomain(ObjectType expected, ObjectType found);
     
     // _verifyAndStoreConfig
     error ConfigMissing();
-    error ConfigServiceTypeInvalid();
-    error ConfigSelectorMissing(); 
-    error ConfigSelectorZero(); 
-    error ConfigSelectorAlreadyExists(VersionPart serviceVersion, ObjectType serviceDomain);
-
-    struct ReleaseInfo {
-        ObjectType[] types; // service types in release
-    }
+    error ConfigServiceDomainInvalid(uint configArrayIndex, ObjectType domain);
+    error ConfigSelectorZero(uint configArrayIndex);
+    error SelectorAlreadyExists(VersionPart releaseVersion, ObjectType serviceDomain);
 
-    // unique role for some service function
-    struct ConfigInfo {
-        bytes4[] selector; // selector used by service
-        RoleId roleId; // roleId granted to service
-    }
 
     RegistryAccessManager private immutable _accessManager;
     IRegistry private immutable _registry;
 
-    VersionPart _latest;// latest active version
-    VersionPart immutable _initial;// first active version
-
-    mapping(VersionPart version => ReleaseInfo info) _release;
+    VersionPart immutable _initial;// first active major version    
+    VersionPart _latest;// latest active major version
+    VersionPart _next;// major version to create and activate 
 
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => ConfigInfo)) _config;
+    mapping(VersionPart majorVersion => IRegistry.ReleaseInfo info) _release;
 
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => address)) _service;
+    mapping(VersionPart majorVersion => mapping(ObjectType serviceDomain => bytes4[])) _selectors; // registry service function selector assigned to domain 
 
     uint _awaitingRegistration; // "services left to register" counter
 
-    mapping(address => bool) _isActiveRegistryService;
+    mapping(address registryService => bool isActive) _active;
+
+    mapping(VersionPart majorVersion => bool isValid) _valid; // TODO refactor to use _active only
 
     constructor(
         RegistryAccessManager accessManager, 
         VersionPart initialVersion)
         AccessManaged(accessManager.authority())
     {
+        require(initialVersion.toInt() > 0, "ReleaseManager: initial version is 0");
+
         _accessManager = accessManager;
 
         _initial = initialVersion;
+        _next = initialVersion;
 
-        _registry = new Registry(address(this), initialVersion);
+        _registry = new Registry();
     }
 
-    // TODO deploy proxy and initialize with given implementation instead of using given proxy?
-    function createNextRelease(IRegistryService registryService)
+    /// @dev skips previous release if was not activated
+    function createNextRelease()
         external
         restricted // GIF_ADMIN_ROLE
-        returns(NftId nftId)
     {
-        if(!registryService.supportsInterface(type(IRegistryService).interfaceId)) {
-            revert NotRegistryService();
-        }
+        // allow to register new registry service for next version
+        VersionPartLib.toVersionPart(_next.toInt() + 1);
+        // disallow registration of regular services for next version while registry service is not registered 
+        _awaitingRegistration = 0;
 
-        if(registryService.authority() != _accessManager.authority()) {
-            revert UnexpectedServiceAuthority(
-                _accessManager.authority(), 
-                registryService.authority()); 
-        }
+        emit LogReleaseCreation(_next); 
+    }
 
-        (
-            IRegistry.ObjectInfo memory info, 
-            bytes memory data
-        ) = _getAndVerifyContractInfo(registryService, SERVICE(), msg.sender);
+    function activateNextRelease() 
+        external 
+        restricted // GIF_ADMIN_ROLE
+    {
+        VersionPart version = _next;
+        address service = _registry.getServiceAddress(REGISTRY(), version);
 
-        VersionPart nextVersion = getNextVersion();
-        _verifyServiceInfo(info, nextVersion, SERVICE());
+        // release was created
+        if(service == address(0)) {
+            revert ReleaseNotCreated();
+        }
 
-        _verifyAndStoreConfig(data);
+        // release fully deployed
+        if(_awaitingRegistration > 0) {
+            revert ReleaseRegistrationNotFinished();
+        }
 
-        //setTargetClosed(newRegistryService, true);
+        //setTargetClosed(service, false);
 
-        _registerService(address(registryService), nextVersion, SERVICE());
-        
-        nftId = _registry.registerService(info);
+        _latest = version;
 
-        // external call
-        registryService.linkToRegisteredNftId();
+        _active[service] = true;
+        _valid[version] = true;
 
-        emit LogReleaseCreation(nextVersion, registryService); 
+        emit LogReleaseActivation(version);
     }
 
-    function registerService(IService service) 
+    // 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
+    // callable once per release after release creation, can not register regular services while registry service is not registered
+    function registerRegistryService(IRegistryService service)
         external
         restricted // GIF_MANAGER_ROLE
         returns(NftId nftId)
     {
-        if(!service.supportsInterface(type(IService).interfaceId)) {
-            revert NotService();
-        }
-
-        (
-            IRegistry.ObjectInfo memory info, 
-            //bytes memory data
-        ) = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
-
-        VersionPart nextVersion = getNextVersion();
-        ObjectType serviceDomain = _verifyServiceInfo(info, nextVersion, zeroObjectType());
-
-        bytes4[] memory selector = _config[nextVersion][serviceDomain].selector;
-
-        // service type is in release
-        if(selector.length == 0) {
-            revert ServiceNotInRelease(service, serviceDomain); 
+        if(!service.supportsInterface(type(IRegistryService).interfaceId)) {
+            revert NotRegistryService();
         }
 
-        // setup and grant unique role
-        address registryService = _registry.getServiceAddress(SERVICE(), nextVersion);
-        RoleId roleId = _accessManager.setAndGrantUniqueRole(
-            address(service), 
-            registryService, 
-            selector);
-
-        _config[nextVersion][serviceDomain].roleId = roleId;
-        _awaitingRegistration--;
-
-        // activate release
-        if(_awaitingRegistration == 0) {
-            _latest = nextVersion;
-            _isActiveRegistryService[registryService] = true;  
-
-            emit LogReleaseActivation(nextVersion);
+        // TODO unreliable! MUST guarantee the same authority -> how?
+        address serviceAuthority = service.authority();
+        if(serviceAuthority != authority()) {
+            revert UnexpectedServiceAuthority(
+                authority(), 
+                serviceAuthority); 
         }
 
-        _registerService(address(service), nextVersion, serviceDomain);
+        IRegistry.ObjectInfo memory info = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
 
-        nftId = _registry.registerService(info);
+        VersionPart majorVersion = _next;
+        ObjectType domain = REGISTRY();
+        _verifyService(service, majorVersion, domain);
+        _createRelease(service.getFunctionConfigs());
+        
+        nftId = _registry.registerService(info, majorVersion, domain);
 
         // external call
-        service.linkToRegisteredNftId(); 
+        service.linkToRegisteredNftId();
     }
 
-    /*function activateNextRelease() 
-        external 
-        restricted // GIF_ADMIN_ROLE
+    // TODO adding service to release -> synchronized with proxy upgrades or simple addServiceToRelease(service, version, selector)?
+    // TODO removing service from release? -> set _active to false forever, but keep all other records?
+    function registerService(IService service) 
+        external
+        restricted // GIF_MANAGER_ROLE
+        returns(NftId nftId)
     {
-        VersionPart nextVersion = getNextVersion();
-        address service = _service[nextVersion][SERVICE()];
-
-        // release was created
-        if(service == address(0)) {
-            revert ReleaseNotCreated();
+        if(!service.supportsInterface(type(IService).interfaceId)) {
+            revert NotService();
         }
 
-        // release fully deployed
-        if(_awaitingRegistration > 0) {
-            revert ReleaseRegistrationNotFinished();
+        IRegistry.ObjectInfo memory info = _getAndVerifyContractInfo(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);
         }
+        
+        _awaitingRegistration--;
 
-        //setTargetClosed(newRegistryService, false);
-
-        _latest = nextVersion;
-        _isActiveRegistryService[service] = true;
+        nftId = _registry.registerService(info, majorVersion, domain);
 
-        LogReleaseActivation(nextVersion);
-    }*/
+        // external call
+        service.linkToRegisteredNftId(); 
+    }
 
     //--- view functions ----------------------------------------------------//
 
     function isActiveRegistryService(address service) external view returns(bool)
     {
-        return _isActiveRegistryService[service];
+        return _active[service];
     }
 
-    function getRegistry() external view returns(address)
+    function isValidRelease(VersionPart version) external view returns(bool)
     {
-        return (address(_registry));
+        return _valid[version];
     }
 
-    function getService(VersionPart serviceVersion, ObjectType serviceDomain) external view returns(address)
+    function getRegistry() external view returns(address)
     {
-        return _service[serviceVersion][serviceDomain];
+        return (address(_registry));
     }
 
-    function getReleaseInfo(VersionPart releaseVersion) external view returns(ReleaseInfo memory)
+    function getReleaseInfo(VersionPart version) external view returns(IRegistry.ReleaseInfo memory)
     {
-        return _release[releaseVersion];
+        return _release[version];
     }
 
     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) {
@@ -249,31 +228,18 @@ contract ReleaseManager is AccessManaged
 
     //--- private functions ----------------------------------------------------//
 
-    function _registerService(address service, VersionPart version, ObjectType serviceDomain) 
-        internal
-    {
-        if(_service[version][serviceDomain] > address(0)) {
-            revert ServiceAlreadyRegistered(service);
-        }
-
-        _service[version][serviceDomain] = service;
-
-        emit LogServiceRegistration(version, serviceDomain);
-    }
-
     function _getAndVerifyContractInfo(
         IService service,
         ObjectType expectedType,
-        address expectedOwner // assume alway valid, can not be 0
+        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 = service.getInitialInfo();
         info.objectAddress = address(service);
         info.isInterceptor = false; // service is never interceptor, at least now
 
@@ -290,88 +256,68 @@ contract ReleaseManager is AccessManaged
         if(owner == address(service)) {
             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 expectedType
+        ObjectType expectedDomain
     )
         internal
         view
         returns(ObjectType)
     {
-        (
-            ObjectType serviceDomain,
-            VersionPart serviceVersion
-        ) = abi.decode(info.data, (ObjectType, VersionPart));
-
-        if(serviceVersion != expectedVersion) {
-            revert UnexpectedServiceVersion(expectedVersion, serviceVersion);
+        Version version = service.getVersion();
+        VersionPart majorVersion = version.toMajorPart();
+        if(majorVersion != expectedVersion) {
+            revert UnexpectedServiceVersion(expectedVersion, majorVersion);
         }
 
-        if(expectedType != zeroObjectType()) { 
-            if(serviceDomain != expectedType) {
-                revert UnexpectedServiceDomain(expectedType, serviceDomain);
-            }
+        if(service.getDomain() != expectedDomain) {
+            revert UnexpectedServiceDomain(expectedDomain, service.getDomain());
         }
 
-        return serviceDomain;
+        return expectedDomain;
     }
 
-    function _verifyAndStoreConfig(bytes memory configBytes)
+    // TODO check if registry supports types specified in the config array
+    function _createRelease(IRegistryService.FunctionConfig[] memory config)
         internal
     {
-        VersionPart nextVersion = getNextVersion();
-        IRegistryService.FunctionConfig[] memory config = abi.decode(configBytes, (IRegistryService.FunctionConfig[]));
+        VersionPart version = getNextVersion();
 
         if(config.length == 0) {
             revert ConfigMissing();
         }
         // always in release
-        _release[nextVersion].types.push(SERVICE());
-
+        _release[version].domains.push(REGISTRY());
         for(uint idx = 0; idx < config.length; idx++)
         {
-            ObjectType serviceDomain = config[idx].serviceDomain;
-            bytes4[] memory selector = config[idx].selector;
-
-            // not "registry service" type
-            if(serviceDomain == SERVICE()) { revert ConfigServiceTypeInvalid(); } 
+            ObjectType domain = config[idx].serviceDomain;
+            // not "registry service" / zero domain
+            if(
+                domain == REGISTRY() ||
+                domain.eqz()
+            ) { revert ConfigServiceDomainInvalid(idx, domain); } 
 
-            // at least one selector exists
-            if(selector.length == 0) { revert ConfigSelectorMissing(); }
-
-            // no zero selectors
-            for(uint jdx = 0; jdx < selector.length; jdx++) {
-                if(selector[jdx] == 0) { revert ConfigSelectorZero(); }
-            }
+            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(_config[nextVersion][serviceDomain].selector.length > 0) { 
-                revert ConfigSelectorAlreadyExists(nextVersion, serviceDomain); 
+            if(_selectors[version][domain].length > 0) {
+                revert SelectorAlreadyExists(version, domain); 
             }
             
-            _config[nextVersion][serviceDomain].selector = selector;
-            _release[nextVersion].types.push(serviceDomain);
+            _selectors[version][domain] = selectors;
+            _release[version].domains.push(domain);
         }
+        // TODO set when activated?
+        _release[version].createdAt = TimestampLib.blockTimestamp();
+        //_release[version].updatedAt = TimestampLib.blockTimestamp();
 
         _awaitingRegistration = config.length;
     }

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 {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
-import {ObjectType, SERVICE} from "../types/ObjectType.sol";
+import {VersionPart} from "../types/Version.sol";
+import {REGISTRY} from "../types/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 -> _latest is 0 before first release activation
-        address registryServiceAddress = registry.getServiceAddress(SERVICE(), 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/ERC165.sol

@@ -2,24 +2,26 @@
 pragma solidity ^0.8.19;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
-contract ERC165 is IERC165 {
+contract ERC165 is
+    Initializable,
+    IERC165
+{
     mapping(bytes4 => bool) private _isSupported;
 
-    constructor() {
-        _initializeERC165();
-    }
-
-    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
-        return _isSupported[interfaceId];
-    }
-
-    // @dev register support for ERC165 itself
-    function _initializeERC165() internal {
+    // @dev initializes with support for ERC165
+    function initializeERC165() public onlyInitializing() {
         _isSupported[type(IERC165).interfaceId] = true;
     }
 
-    function _registerInterface(bytes4 interfaceId) internal {
+    // @dev register support for provided interfaceId
+    // includes initialization for ERC165_ID if not yet done
+    function registerInterface(bytes4 interfaceId) public onlyInitializing() {
         _isSupported[interfaceId] = true;
     }
+
+    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
+        return _isSupported[interfaceId];
+    }
 }

package/contracts/shared/INftOwnable.sol

@@ -1,22 +1,23 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {IRegistry} from "../registry/IRegistry.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IRegistryLinked} from "./IRegistryLinked.sol";
 import {NftId} from "../types/NftId.sol";
 
-interface INftOwnable {
-    error ErrorNotOwner(address account);
+interface INftOwnable is
+    IERC165,
+    IRegistryLinked
+{
+    error ErrorNftOwnableInitialOwnerZero();
+    error ErrorNftOwnableNotOwner(address account);
 
-    error ErrorAlreadyLinked(address registry, NftId nftId);
-    error ErrorRegistryAlreadyInitialized(address registry);
-    error ErrorRegistryNotInitialized();
-    error ErrorRegistryAddressZero();
-    error ErrorNotRegistry(address registryAddress);
-    error ErrorContractNotRegistered(address contractAddress);
+    error ErrorNftOwnableAlreadyLinked(NftId nftId);
+    error ErrorNftOwnableContractNotRegistered(address contractAddress);
 
     function linkToRegisteredNftId() external;
 
-    function getRegistry() external view returns (IRegistry);
     function getNftId() external view returns (NftId);
     function getOwner() external view returns (address);
 }