@etherisc/gif-next 0.0.2-9d3eab3-323 → 0.0.2-9f827bd-593

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 {ObjectType, ObjectTypeLib, zeroObjectType, REGISTRY, SERVICE} from "../types/ObjectType.sol";
 import {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
 {
+    using ObjectTypeLib for ObjectType;
+
     event LogReleaseCreation(VersionPart version, IService registryService); 
-    event LogServiceRegistration(VersionPart majorVersion, ObjectType serviceDomain); 
     event LogReleaseActivation(VersionPart version);
 
     // createNextRelease
@@ -34,7 +31,6 @@ contract ReleaseManager is AccessManaged
     // registerService
     error NotService();
     error ServiceNotInRelease(IService service, ObjectType serviceDomain);
-    error ServiceAlreadyRegistered(address service);
 
     // activateNextRelease
     //error ReleaseNotCreated();
@@ -42,7 +38,7 @@ contract ReleaseManager is AccessManaged
 
     // _getAndVerifyContractInfo
     error UnexpectedRegisterableType(ObjectType expected, ObjectType found);
-    error NotRegisterableOwner(address expectedOwner);
+    error NotRegisterableOwner(address notOwner);
     error SelfRegistration();
     error RegisterableOwnerIsRegistered();
 
@@ -52,20 +48,10 @@ contract ReleaseManager is AccessManaged
     
     // _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;
@@ -73,66 +59,68 @@ contract ReleaseManager is AccessManaged
     VersionPart _latest;// latest active version
     VersionPart immutable _initial;// first active version
 
-    mapping(VersionPart version => ReleaseInfo info) _release;
-
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => ConfigInfo)) _config;
+    mapping(VersionPart version => IRegistry.ReleaseInfo info) _release;
 
-    mapping(VersionPart version => mapping(ObjectType serviceDomain => address)) _service;
+    mapping(VersionPart version => mapping(ObjectType serviceDomain => bytes4)) _selector; // registry service function selector assigned to domain 
 
     uint _awaitingRegistration; // "services left to register" counter
 
-    mapping(address => bool) _isActiveRegistryService;
+    mapping(address registryService => bool isActive) _active;
 
     constructor(
         RegistryAccessManager accessManager, 
         VersionPart initialVersion)
         AccessManaged(accessManager.authority())
     {
+        require(initialVersion.toInt() > 0, "ReleaseManager: initial version is 0");
+
         _accessManager = accessManager;
 
         _initial = 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)
+    // IMPORTANT: MUST never be possible to create with access/release manager, token registry
+    function createNextRelease(IRegistryService service)
         external
         restricted // GIF_ADMIN_ROLE
         returns(NftId nftId)
     {
-        if(!registryService.supportsInterface(type(IRegistryService).interfaceId)) {
+        if(!service.supportsInterface(type(IRegistryService).interfaceId)) {
             revert NotRegistryService();
         }
-
-        if(registryService.authority() != _accessManager.authority()) {
+        // TODO unreliable! MUST guarantee the same authority -> how?
+        if(service.authority() != authority()) {
             revert UnexpectedServiceAuthority(
-                _accessManager.authority(), 
-                registryService.authority()); 
+                authority(), 
+                service.authority()); 
         }
 
         (
             IRegistry.ObjectInfo memory info, 
             bytes memory data
-        ) = _getAndVerifyContractInfo(registryService, SERVICE(), msg.sender);
-
-        VersionPart nextVersion = getNextVersion();
-        _verifyServiceInfo(info, nextVersion, SERVICE());
+        ) = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
 
-        _verifyAndStoreConfig(data);
+        VersionPart version = getNextVersion();
+        ObjectType domain = REGISTRY();
+        _verifyServiceInfo(info, version, domain);
 
-        //setTargetClosed(newRegistryService, true);
+        _createRelease(data);
 
-        _registerService(address(registryService), nextVersion, SERVICE());
+        //setTargetClosed(service, true);
         
-        nftId = _registry.registerService(info);
+        nftId = _registry.registerService(info, version, domain);
 
         // external call
-        registryService.linkToRegisteredNftId();
+        service.linkToRegisteredNftId();
 
-        emit LogReleaseCreation(nextVersion, registryService); 
+        emit LogReleaseCreation(version, service); 
     }
 
+    // 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
@@ -147,37 +135,35 @@ contract ReleaseManager is AccessManaged
             //bytes memory data
         ) = _getAndVerifyContractInfo(service, SERVICE(), msg.sender);
 
-        VersionPart nextVersion = getNextVersion();
-        ObjectType serviceDomain = _verifyServiceInfo(info, nextVersion, zeroObjectType());
+        VersionPart version = getNextVersion();
+        ObjectType domain = _verifyServiceInfo(info, version, zeroObjectType());
 
-        bytes4[] memory selector = _config[nextVersion][serviceDomain].selector;
+        bytes4[] memory selector = new bytes4[](1);
+        selector[0] = _selector[version][domain];
 
         // service type is in release
-        if(selector.length == 0) {
-            revert ServiceNotInRelease(service, serviceDomain); 
+        if(selector[0] == 0) {
+            revert ServiceNotInRelease(service, domain);
         }
 
         // setup and grant unique role
-        address registryService = _registry.getServiceAddress(SERVICE(), nextVersion);
-        RoleId roleId = _accessManager.setAndGrantUniqueRole(
+        address registryService = _registry.getServiceAddress(REGISTRY(), version);
+        _accessManager.setAndGrantUniqueRole(
             address(service), 
             registryService, 
             selector);
 
-        _config[nextVersion][serviceDomain].roleId = roleId;
         _awaitingRegistration--;
 
         // activate release
         if(_awaitingRegistration == 0) {
-            _latest = nextVersion;
-            _isActiveRegistryService[registryService] = true;  
+            _latest = version;
+            _active[registryService] = true;  
 
-            emit LogReleaseActivation(nextVersion);
+            emit LogReleaseActivation(version);
         }
 
-        _registerService(address(service), nextVersion, serviceDomain);
-
-        nftId = _registry.registerService(info);
+        nftId = _registry.registerService(info, version, domain);
 
         // external call
         service.linkToRegisteredNftId(); 
@@ -187,8 +173,8 @@ contract ReleaseManager is AccessManaged
         external 
         restricted // GIF_ADMIN_ROLE
     {
-        VersionPart nextVersion = getNextVersion();
-        address service = _service[nextVersion][SERVICE()];
+        VersionPart version = getNextVersion();
+        address service = _registry.getServiceAddress(REGISTRY(), version);
 
         // release was created
         if(service == address(0)) {
@@ -200,19 +186,19 @@ contract ReleaseManager is AccessManaged
             revert ReleaseRegistrationNotFinished();
         }
 
-        //setTargetClosed(newRegistryService, false);
+        //setTargetClosed(service, false);
 
-        _latest = nextVersion;
-        _isActiveRegistryService[service] = true;
+        _latest = version;
+        _active[service] = true;
 
-        LogReleaseActivation(nextVersion);
+        LogReleaseActivation(version);
     }*/
 
     //--- view functions ----------------------------------------------------//
 
     function isActiveRegistryService(address service) external view returns(bool)
     {
-        return _isActiveRegistryService[service];
+        return _active[service];
     }
 
     function getRegistry() external view returns(address)
@@ -220,14 +206,9 @@ contract ReleaseManager is AccessManaged
         return (address(_registry));
     }
 
-    function getService(VersionPart serviceVersion, ObjectType serviceDomain) external view returns(address)
+    function getReleaseInfo(VersionPart version) external view returns(IRegistry.ReleaseInfo memory)
     {
-        return _service[serviceVersion][serviceDomain];
-    }
-
-    function getReleaseInfo(VersionPart releaseVersion) external view returns(ReleaseInfo memory)
-    {
-        return _release[releaseVersion];
+        return _release[version];
     }
 
     function getNextVersion() public view returns(VersionPart) 
@@ -249,22 +230,10 @@ 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
@@ -312,66 +281,67 @@ contract ReleaseManager is AccessManaged
     function _verifyServiceInfo(
         IRegistry.ObjectInfo memory info,
         VersionPart expectedVersion,
-        ObjectType expectedType
+        ObjectType expectedDomain
     )
         internal
         view
         returns(ObjectType)
     {
         (
-            ObjectType serviceDomain,
-            VersionPart serviceVersion
+            ObjectType domain,
+            VersionPart version
         ) = abi.decode(info.data, (ObjectType, VersionPart));
 
-        if(serviceVersion != expectedVersion) {
-            revert UnexpectedServiceVersion(expectedVersion, serviceVersion);
+        if(version != expectedVersion) {
+            revert UnexpectedServiceVersion(expectedVersion, version);
         }
 
-        if(expectedType != zeroObjectType()) { 
-            if(serviceDomain != expectedType) {
-                revert UnexpectedServiceDomain(expectedType, serviceDomain);
+        if(expectedDomain.gtz()) { 
+            if(domain != expectedDomain) {
+                revert UnexpectedServiceDomain(expectedDomain, domain);
             }
         }
 
-        return serviceDomain;
+        return domain;
     }
 
-    function _verifyAndStoreConfig(bytes memory configBytes)
+    // TODO check if registry supports types specified in the config array
+    function _createRelease(bytes memory configBytes)
         internal
     {
-        VersionPart nextVersion = getNextVersion();
+        VersionPart version = getNextVersion();
         IRegistryService.FunctionConfig[] memory config = abi.decode(configBytes, (IRegistryService.FunctionConfig[]));
 
         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;
+            ObjectType domain = config[idx].serviceDomain;
+            bytes4 selector = config[idx].selector;
 
-            // not "registry service" type
-            if(serviceDomain == SERVICE()) { revert ConfigServiceTypeInvalid(); } 
+            // 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(); }
-            }
+            // selector not zero
+            if(selector == 0) { revert ConfigSelectorZero(idx); }
 
             // no overwrite
-            if(_config[nextVersion][serviceDomain].selector.length > 0) { 
-                revert ConfigSelectorAlreadyExists(nextVersion, serviceDomain); 
+            if(_selector[version][domain] > 0) {
+                revert SelectorAlreadyExists(version, domain); 
             }
             
-            _config[nextVersion][serviceDomain].selector = selector;
-            _release[nextVersion].types.push(serviceDomain);
+            _selector[version][domain] = selector;
+            _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.
@@ -37,8 +37,8 @@ contract TokenRegistry is
         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 `next version` -> but _latest is 0 before first release activation
+        address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getMajorVersionMax());
 
         _linkToNftOwnable(registryAddress, registryServiceAddress);
     }

package/contracts/types/RoleId.sol

@@ -24,20 +24,19 @@ function PRODUCT_OWNER_ROLE_NAME() pure returns (string memory) { return "Produc
 
 function ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(0); }
 
-// TODO correct numbers (maybe they are already defined in RegistryService)
 function DISTRIBUTION_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(100); }
 function ORACLE_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(200); }
 function POOL_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(300); }
 function PRODUCT_OWNER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(400); }
 
 
-function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10000); }
-function POOL_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10100); }
-function PRODUCT_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10200); }
-function POLICY_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10300); }
-function BUNDLE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(10400); }
+function INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2000); }
+function DISTRIBUTION_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2100); }
+function POOL_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2200); }
+function PRODUCT_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2300); }
+function POLICY_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2400); }
+function BUNDLE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(2500); }
 
-function INSTANCE_SERVICE_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(11000); }
 
 function REGISTRY_SERVICE_ADMIN_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1500); } 
 function REGISTRY_SERVICE_MANAGER_ROLE() pure returns (RoleId) { return RoleIdLib.toRoleId(1600); } 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-9d3eab3-323",
+  "version": "0.0.2-9f827bd-593",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {

package/artifacts/contracts/instance/IAccessManagerSimple.sol/IAccessManagerSimple.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/9e136355c5434b5ac775c99554f09c5c.json"
-}