@etherisc/gif-next 3.0.0-1b49bd6-565 → 3.0.0-1c2086e-623

package/contracts/registry/Registry.sol

@@ -2,7 +2,6 @@
 pragma solidity ^0.8.20;
 
 import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 
@@ -10,16 +9,14 @@ import {NftId, NftIdLib} from "../type/NftId.sol";
 import {VersionPart, VersionPartLib} from "../type/Version.sol";
 import {ObjectType, ObjectTypeLib, PROTOCOL, REGISTRY, SERVICE, INSTANCE, STAKE, STAKING, PRODUCT, DISTRIBUTION, DISTRIBUTOR, ORACLE, POOL, POLICY, BUNDLE} from "../type/ObjectType.sol";
 
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
 import {ChainNft} from "./ChainNft.sol";
 import {IRegistry} from "./IRegistry.sol";
 import {IRelease} from "./IRelease.sol";
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IStaking} from "../staking/IStaking.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
-import {TokenRegistry} from "./TokenRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
-import {Versionable} from "../shared/Versionable.sol";
-import {VersionLib, Version} from "../type/Version.sol";
 
 /// @dev IMPORTANT
 // Each NFT minted by registry is accosiated with:
@@ -33,27 +30,20 @@ import {VersionLib, Version} from "../type/Version.sol";
 // 5) registerRegistry() -> registers IRegistry address (from different chain) by GifAdmin. Works ONLY on mainnet. 
 //                          Note: getters by address MUST not be used with this address (will return 0 or data related to different object or even revert)
 
-
-function GIF_INITIAL_RELEASE() pure returns (VersionPart) {
-    return VersionPartLib.toVersionPart(3);
-}
-
-
 /// @dev Chain Registry contract implementing IRegistry.
 /// IRegistry for method details.
 contract Registry is
     Initializable,
     AccessManaged,
-    Versionable,
     IRegistry
 {
     /// @dev Protocol NFT ID
     NftId public immutable PROTOCOL_NFT_ID;
 
-    /// @dev Global registry NFT ID
+    /// @dev Gobal registry NFT ID
     NftId public immutable GLOBAL_REGISTRY_NFT_ID;
 
-    /// @dev Global registry address on mainnet.
+    /// @dev Gobal registry address on mainnet.
     address public immutable GLOBAL_REGISTRY_ADDRESS;
 
     /// @dev Registry NFT ID
@@ -74,12 +64,11 @@ contract Registry is
     string public constant EMPTY_URI = "";
 
     /// @dev keep track of different registries on different chains
-    mapping(uint256 chainId => NftId registryNftId) private _registryNftIdByChainId;
-    uint256[] private _chainId;
+    mapping(ChainId chainId => NftId registryNftId) private _registryNftIdByChainId;
+    ChainId[] private _chainId;
 
-    /// @dev keep track of object info, data and address reverse lookup
+    /// @dev keep track of object info and address reverse lookup
     mapping(NftId nftId => ObjectInfo info) private _info;
-    mapping(NftId nftId => bytes data) private _data;
     mapping(address object => NftId nftId) private _nftIdByAddress;
 
     /// @dev keep track of service addresses by version and domain
@@ -155,20 +144,19 @@ contract Registry is
     /// @inheritdoc IRegistry
     function registerRegistry(
         NftId nftId,
-        uint256 chainId, 
-        address registryAddress,
-        VersionPart release
+        ChainId chainId, 
+        address registryAddress
     )
         external
         restricted()
     {
         // registration of chain registries only allowed on mainnet
         if (block.chainid != 1) {
-            revert ErrorRegistryNotOnMainnet(block.chainid);
+            revert ErrorRegistryNotOnMainnet(ChainIdLib.toChainId(block.chainid));
         }
 
         // registry chain id is not zero
-        if(chainId == 0) {
+        if(chainId.eqz()) {
             revert ErrorRegistryChainRegistryChainIdZero(nftId);
         }
 
@@ -191,19 +179,20 @@ contract Registry is
                 nftId: nftId,
                 parentNftId: REGISTRY_NFT_ID,
                 objectType: REGISTRY(),
-                release: release,
                 isInterceptor: false,
-                objectAddress: registryAddress}),
+                objectAddress: registryAddress,
+                initialOwner: NFT_LOCK_ADDRESS,
+                data: ""  
+            }),
             false); // do not update address lookup for objects on a different chain
     }
 
     // TODO limit service owner to registry admin?
     /// @inheritdoc IRegistry
     function registerService(
-        ObjectInfo memory info,
-        address initialOwner,
-        ObjectType domain,
-        bytes memory data
+        ObjectInfo memory info, 
+        VersionPart version, 
+        ObjectType domain
     )
         external
         restricted()
@@ -216,13 +205,12 @@ contract Registry is
         }
 
         // version is defined
-        VersionPart release = info.release;
-        if(release.eqz()) {
+        if(version.eqz()) {
             revert ErrorRegistryServiceVersionZero(service);
         }
         // service domain is defined
         if(domain.eqz()) {
-            revert ErrorRegistryServiceDomainZero(service, release);
+            revert ErrorRegistryServiceDomainZero(service, version);
         }
 
         // service has proper type
@@ -232,31 +220,30 @@ contract Registry is
 
         // service parent has registry type
         if(info.parentNftId != REGISTRY_NFT_ID) {
-            revert ErrorRegistryServiceParentNotRegistry(service, release, info.parentNftId);
+            revert ErrorRegistryServiceParentNotRegistry(service, version, info.parentNftId);
         }
 
         // service has not already been registered
-        if(_service[release][domain] != address(0)) {
-            revert ErrorRegistryServiceDomainAlreadyRegistered(service, release, domain);
+        if(_service[version][domain] != address(0)) {
+            revert ErrorRegistryServiceDomainAlreadyRegistered(service, version, domain);
         }
 
-        _service[release][domain] = service;
+        _service[version][domain] = service;
 
-        emit LogRegistryServiceRegistered(release, domain);
+        emit LogRegistryServiceRegistered(info.nftId,version, domain);
 
-        nftId = _register(info, initialOwner, data);
+        nftId = _register(info);
     }
 
 
     /// @inheritdoc IRegistry
-    function register(ObjectInfo memory info, address initialOwner, bytes memory data)
+    function register(ObjectInfo memory info)
         external
         restricted()
         returns(NftId nftId)
     {
         address objectAddress = info.objectAddress;
         ObjectType objectType = info.objectType;
-        VersionPart parentRelease = _info[info.parentNftId].release;
 
         // specialized functions have to be used to register registries and services
         if(objectType == REGISTRY() || objectType == STAKING() || objectType == SERVICE()) {
@@ -280,21 +267,18 @@ contract Registry is
             }
         }
 
-        _checkRelease(info.release, parentRelease, parentType);
-
-        nftId = _register(info, initialOwner, data);
+        nftId = _register(info);
     }
 
 
     /// @inheritdoc IRegistry
-    function registerWithCustomType(ObjectInfo memory info, address initialOwner, bytes memory data)
+    function registerWithCustomType(ObjectInfo memory info)
         external
         restricted()
         returns(NftId nftId)
     {
         ObjectType objectType = info.objectType;
         ObjectType parentType = _info[info.parentNftId].objectType;
-        VersionPart parentRelease = _info[info.parentNftId].release;
 
         if(_coreTypes[objectType]) {
             revert ErrorRegistryCoreTypeRegistration();
@@ -310,36 +294,13 @@ contract Registry is
             revert ErrorRegistryTypeCombinationInvalid(info.objectAddress, objectType, parentType);
         }
 
-        _checkRelease(info.release, parentRelease, parentType);
-
-        nftId = _register(info, initialOwner, data);
+        nftId = _register(info);
     }
 
-    function _checkRelease(
-        VersionPart objectRelease, 
-        VersionPart parentRelease,
-        ObjectType parentType
-    ) internal view
-    {
-        VersionPart senderRelease = _info[_nftIdByAddress[msg.sender]].release;
-
-        // assume:
-        // 1) only address with role can reach this function -> caller is registered registry service
-        // 2) locked registry service can not call registry -> no "caller is locked" check is needed
-        if(parentType == PROTOCOL()) {
-            // STAKING for PROTOCOL, parent release is 0
-            if(senderRelease != objectRelease) {
-                revert ErrorRegistryReleaseMismatch(objectRelease, parentRelease, senderRelease);
-            }
-        }
-        else if(senderRelease != objectRelease || senderRelease != parentRelease) {
-            revert ErrorRegistryReleaseMismatch(objectRelease, parentRelease, senderRelease);
-        }
-    }
 
     /// @dev earliest GIF major version 
     function getInitialRelease() external view returns (VersionPart) {
-        return GIF_INITIAL_RELEASE();
+        return VersionPartLib.toVersionPart(_releaseRegistry.INITIAL_GIF_VERSION());
     }
 
     /// @dev next GIF release version to be released
@@ -360,11 +321,11 @@ contract Registry is
         return _chainId.length;
     }
 
-    function getChainId(uint256 idx) public view returns (uint256) {
+    function getChainId(uint256 idx) public view returns (ChainId) {
         return _chainId[idx];
     }
 
-    function getRegistryNftId(uint256 chainId) public view returns (NftId nftId) {
+    function getRegistryNftId(ChainId chainId) public view returns (NftId nftId) {
         return _registryNftIdByChainId[chainId];
     }
 
@@ -404,20 +365,13 @@ contract Registry is
         return _info[nftId].parentNftId;
     }
 
-    function isObjectType(address contractAddress, ObjectType expectedObjectType, VersionPart release) external view returns (bool) {
+    function isObjectType(address contractAddress, ObjectType expectedObjectType) external view returns (bool) {
         NftId nftId = _nftIdByAddress[contractAddress];
-        return isObjectType(nftId, expectedObjectType, release);
-    }
-
-    function isObjectType(NftId nftId, ObjectType expectedObjectType, VersionPart release) public view returns (bool) {
-        return (
-            _info[nftId].objectType == expectedObjectType &&
-            _info[nftId].release == release
-        );
+        return isObjectType(nftId, expectedObjectType);
     }
 
-    function getObjectRelease(NftId nftId) external view returns (VersionPart release)  {
-        return _info[nftId].release;
+    function isObjectType(NftId nftId, ObjectType expectedObjectType) public view returns (bool) {
+        return _info[nftId].objectType == expectedObjectType;
     }
 
     function getObjectAddress(NftId nftId) external view returns (address) {
@@ -428,14 +382,6 @@ contract Registry is
         return _info[_nftIdByAddress[object]];
     }
 
-    function getObjectData(NftId nftId) external view returns (bytes memory data) {
-        return _data[nftId];
-    }
-
-    function getObjectData(address objectAddress) external view returns (bytes memory data) {
-        return _data[_nftIdByAddress[objectAddress]];
-    }
-
     function isRegistered(NftId nftId) public view returns (bool) {
         return _info[nftId].objectType.gtz();
     }
@@ -494,12 +440,6 @@ contract Registry is
         return ownerOf(address(this));
     }
 
-    // Versionable
-
-    function getVersion() public pure override returns (Version) {
-        return VersionLib.toVersion(GIF_INITIAL_RELEASE().toInt(), 0 , 0);
-    }
-
     // IERC165
 
     function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
@@ -513,49 +453,62 @@ contract Registry is
     // Internals
 
     /// @dev registry protects only against tampering existing records, registering with invalid types pairs and 0 parent address
-    function _register(ObjectInfo memory info, address initialOwner, bytes memory data)
+    function _register(ObjectInfo memory info)
         internal
         returns(NftId nftId)
     {
+        ObjectType objectType = info.objectType; // do not care here, never PROTOCOL(), REGISTRY()
+        bool isInterceptor = info.isInterceptor;
+        address objectAddress = info.objectAddress; // do not care here, can be 0
+        address owner = info.initialOwner; // do not care here, can be 0, can be equal info.objectAddress
+
         NftId parentNftId = info.parentNftId; // do not care here, can not be 0
         ObjectInfo memory parentInfo = _info[parentNftId];
+        address parentAddress = parentInfo.objectAddress; // can be 0
+
+        // parent is contract -> need to check? -> check before minting
+        // special case: staking: to protocol possible as well
+        // NO LONGER TRUE: special case: global registry nft as parent when not on mainnet -> global registry address is 0
+        // special case: when parentNftId == CHAIN_NFT.mint(), check for zero parent address before mint
+        // special case: when parentNftId == CHAIN_NFT.mint() && objectAddress == initialOwner
+        // Parent can have 0 address in case of STAKE for PROTOCOL / CUSTOM_TYPE for POLICY
+        // But it MUST be registered -> parentType != 0 && parentNftId != 0
+        /*if(objectType != STAKE()) {
+            if(parentAddress == address(0)) {
+                revert ErrorRegistryParentAddressZero();
+            }
+        }*/
     
         // global registry is never parent when not on mainnet
         if(block.chainid != 1) {
             if(parentNftId == GLOBAL_REGISTRY_NFT_ID) {
-                revert ErrorRegistryGlobalRegistryAsParent(info.objectAddress, info.objectType);
+                revert ErrorRegistryGlobalRegistryAsParent(objectAddress, objectType);
             }
         }
 
         address interceptorAddress = _getInterceptor(
-            info.isInterceptor, 
-            info.objectType, 
-            info.objectAddress, 
+            isInterceptor, 
+            objectType, 
+            objectAddress, 
             parentInfo.isInterceptor, 
-            parentInfo.objectAddress);
-
-        uint256 tokenId = CHAIN_NFT.mint(
-            initialOwner,
-            interceptorAddress,
-            EMPTY_URI);
+            parentAddress);
 
+        uint256 tokenId = CHAIN_NFT.getNextTokenId();
         nftId = NftIdLib.toNftId(tokenId);
         info.nftId = nftId;
 
         _info[nftId] = info;
-        if(data.length > 0) {
-            _data[nftId] = data;
-        }
-        _setAddressForNftId(nftId, info.objectAddress);
+        _setAddressForNftId(nftId, objectAddress);
+
+        emit LogRegistryObjectRegistered(nftId, parentNftId, objectType, isInterceptor, objectAddress, owner);
+
+        // calls nft receiver(1) and interceptor(2)
+        uint256 mintedTokenId = CHAIN_NFT.mint(
+            owner,
+            interceptorAddress,
+            EMPTY_URI);
 
-        emit LogRegistryObjectRegistered(
-            nftId, 
-            parentNftId, 
-            info.objectType,
-            info.release,
-            info.isInterceptor, 
-            info.objectAddress, 
-            initialOwner);
+        assert(mintedTokenId == tokenId);        
     }
 
     /// @dev obtain interceptor address for this nft if applicable, address(0) otherwise
@@ -607,11 +560,13 @@ contract Registry is
                 nftId: protocolNftId,
                 parentNftId: NftIdLib.zero(),
                 objectType: PROTOCOL(),
-                release: VersionPartLib.toVersionPart(0),
                 isInterceptor: false, 
-                objectAddress: address(0)}),
-            NFT_LOCK_ADDRESS, // initial owner of protocol
+                objectAddress: address(0),
+                initialOwner: NFT_LOCK_ADDRESS,
+                data: ""}),
             true);
+
+        emit LogRegistryObjectRegistered(protocolNftId, NftIdLib.zero(), PROTOCOL(), false, address(0), NFT_LOCK_ADDRESS);
     }
 
     /// @dev register this registry
@@ -625,14 +580,15 @@ contract Registry is
 
         // register global registry
         _registerRegistryForNft(
-            1, // mainnet chain id
+            ChainIdLib.toChainId(1), // mainnet chain id
             ObjectInfo({
                 nftId: GLOBAL_REGISTRY_NFT_ID,
                 parentNftId: PROTOCOL_NFT_ID,
                 objectType: REGISTRY(),
-                release: getRelease(),
                 isInterceptor: false,
-                objectAddress: GLOBAL_REGISTRY_ADDRESS}),
+                objectAddress: GLOBAL_REGISTRY_ADDRESS, 
+                initialOwner: NFT_LOCK_ADDRESS,
+                data: ""}),
             block.chainid == 1);// update address lookup for global registry only on mainnet
 
         // if not on mainnet: register this registry with global registry as parent
@@ -643,21 +599,22 @@ contract Registry is
                 CHAIN_NFT.calculateTokenId(REGISTRY_TOKEN_SEQUENCE_ID));
 
             _registerRegistryForNft(
-                block.chainid, 
+                ChainIdLib.toChainId(block.chainid), 
                 ObjectInfo({
                     nftId: registryNftId,
                     parentNftId: GLOBAL_REGISTRY_NFT_ID,
                     objectType: REGISTRY(),
-                    release: getRelease(),
                     isInterceptor: false,
-                    objectAddress: address(this)}),
+                    objectAddress: address(this),
+                    initialOwner: NFT_LOCK_ADDRESS,
+                    data: ""}),
                 true);
         }
     }
 
     /// @dev staking registration
     function _registerRegistryForNft(
-        uint256 chainId,
+        ChainId chainId,
         ObjectInfo memory info,
         bool updateAddressLookup
     )
@@ -674,7 +631,6 @@ contract Registry is
         // register the registry info
         _registerForNft(
             info,
-            NFT_LOCK_ADDRESS, // initial owner of any registry
             updateAddressLookup); 
     }
 
@@ -692,10 +648,10 @@ contract Registry is
                 nftId: stakingNftId,
                 parentNftId: REGISTRY_NFT_ID,
                 objectType: STAKING(),
-                release: VersionPartLib.toVersionPart(3),
                 isInterceptor: false,
-                objectAddress: _stakingAddress}),
-            stakingOwner,
+                objectAddress: _stakingAddress, 
+                initialOwner: stakingOwner,
+                data: ""}),
             true); 
 
         IStaking(_stakingAddress).initializeTokenHandler();
@@ -703,8 +659,7 @@ contract Registry is
 
     /// @dev Register the provided object info for the specified NFT ID.
     function _registerForNft(
-        ObjectInfo memory info,
-        address initialOwner,
+        ObjectInfo memory info, 
         bool updateAddressLookup
     )
         internal
@@ -716,7 +671,9 @@ contract Registry is
         }
 
         // calls nft receiver
-        CHAIN_NFT.mint(initialOwner, info.nftId.toInt());
+        CHAIN_NFT.mint(info.initialOwner, info.nftId.toInt());
+
+        emit LogRegistryObjectRegistered(info.nftId, info.parentNftId, info.objectType, info.isInterceptor, info.objectAddress, info.initialOwner);
     }
 
     function _setAddressForNftId(NftId nftId, address objectAddress)

package/contracts/registry/RegistryAdmin.sol

@@ -7,11 +7,12 @@ import {IService} from "../shared/IService.sol";
 import {IStaking} from "../staking/IStaking.sol";
 
 import {AccessAdmin} from "../authorization/AccessAdmin.sol";
+import {AccessAdminLib} from "../authorization/AccessAdminLib.sol";
 import {AccessManagerCloneable} from "../authorization/AccessManagerCloneable.sol";
 import {ObjectType, REGISTRY} from "../type/ObjectType.sol";
 import {RoleId, RoleIdLib, GIF_MANAGER_ROLE, GIF_ADMIN_ROLE} from "../type/RoleId.sol";
-import {GIF_INITIAL_RELEASE} from "../registry/Registry.sol";
 import {Str} from "../type/String.sol";
+import {VersionPart} from "../type/Version.sol";
 
 /*
     1) GIF_MANAGER_ROLE
@@ -51,6 +52,7 @@ contract RegistryAdmin is
     // completeSetup
     error ErrorRegistryAdminNotRegistry(address registry);
 
+    address internal _registry;
     address private _releaseRegistry;
     address private _tokenRegistry;
     address private _staking;
@@ -60,34 +62,49 @@ contract RegistryAdmin is
     constructor() {
         initialize(
             address(new AccessManagerCloneable()),
-            "RegistryAdmin",
-            GIF_INITIAL_RELEASE());
+            "RegistryAdmin");
     }
 
 
     function completeSetup(
+        address registry,
         address authorization,
+        VersionPart release,
         address gifAdmin, 
         address gifManager
     )
         public
         virtual
+        reinitializer(type(uint8).max)
     {
         // checks
-        _checkAuthorization(authorization, REGISTRY(), getRelease(), false, true);
-
-        // effects
+        AccessAdminLib.checkRegistry(registry);
+
+        AccessManagerCloneable(
+            authority()).completeSetup(
+                registry, 
+                release); 
+
+        AccessAdminLib.checkAuthorization(
+            address(_authorization),
+            authorization, 
+            REGISTRY(), 
+            release, 
+            false, // expectServiceAuthorization
+            false); // checkAlreadyInitialized);
+
+        _registry = registry;
         _authorization = IAuthorization(authorization);
 
-        IRegistry registry = _getRegistry();
-        _releaseRegistry = registry.getReleaseRegistryAddress();
-        _tokenRegistry = registry.getTokenRegistryAddress();
-        _staking = registry.getStakingAddress();
+        IRegistry registryContract = IRegistry(registry);
+        _releaseRegistry = registryContract.getReleaseRegistryAddress();
+        _tokenRegistry = registryContract.getTokenRegistryAddress();
+        _staking = registryContract.getStakingAddress();
         _stakingTargetHandler = address(IStaking(_staking).getTargetHandler());
         _stakingStore = address(IStaking(_staking).getStakingStore());
 
         // link nft ownability to registry
-        _linkToNftOwnable(address(_getRegistry()));
+        _linkToNftOwnable(_registry);
 
         _createRoles(_authorization);
 
@@ -132,7 +149,7 @@ contract RegistryAdmin is
         internal
     {
         // create unchecked registry targets
-        _createTarget(address(_getRegistry()), registryTargetName, TargetType.Core, false);
+        _createTarget(_registry, registryTargetName, TargetType.Core, false);
         _createTarget(address(this), REGISTRY_ADMIN_TARGET_NAME, TargetType.Core, false);
         _createTarget(_releaseRegistry, RELEASE_REGISTRY_TARGET_NAME, TargetType.Core, false);
         _createTarget(_tokenRegistry, TOKEN_REGISTRY_TARGET_NAME, TargetType.Core, false);

package/contracts/registry/RegistryAuthorization.sol

@@ -12,7 +12,6 @@ import {PUBLIC_ROLE} from "../type/RoleId.sol";
 import {ReleaseRegistry} from "./ReleaseRegistry.sol";
 import {RegistryAdmin} from "./RegistryAdmin.sol";
 import {RoleIdLib, ADMIN_ROLE, GIF_ADMIN_ROLE, GIF_MANAGER_ROLE} from "../type/RoleId.sol";
-import {GIF_INITIAL_RELEASE} from "../registry/Registry.sol";
 import {StakingStore} from "../staking/StakingStore.sol";
 import {TargetHandler} from "../staking/TargetHandler.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
@@ -50,7 +49,7 @@ contract RegistryAuthorization
           Authorization(
                REGISTRY_TARGET_NAME, 
                REGISTRY(), 
-               GIF_INITIAL_RELEASE(),
+               3, 
                commitHash, 
                TargetType.Core,
                false) // includeTokenHandler
@@ -101,7 +100,7 @@ contract RegistryAuthorization
                AccessAdminLib.roleInfo(
                     ADMIN_ROLE(),
                     TargetType.Custom, // custom is only type that allows role removal
-                    1, // TODO decide on max member count
+                    2, // TODO decide on max member count
                     GIF_ADMIN_ROLE_NAME));
 
           // gif manager role
@@ -110,7 +109,7 @@ contract RegistryAuthorization
                AccessAdminLib.roleInfo(
                     ADMIN_ROLE(),
                     TargetType.Custom, // custom is only type that allows role removal
-                    2, // TODO decide on max member count
+                    1, // TODO decide on max member count
                     GIF_MANAGER_ROLE_NAME));
 
      }
@@ -145,8 +144,6 @@ contract RegistryAuthorization
           _setupStakingThAuthorization();
      }
 
-     event LogAccessAdminDebug(string message, string custom, uint256 value);
-
      function _setupRegistryAuthorization() internal {
           IAccess.FunctionInfo[] storage functions;