@etherisc/gif-next 3.0.0-c458de2-735 → 3.0.0-c517f31-287

package/contracts/registry/IRegistry.sol

@@ -19,8 +19,8 @@ interface IRegistry is
     IERC165
 {
 
-    event LogRegistryObjectRegistered(NftId nftId, NftId parentNftId, ObjectType objectType, VersionPart objectVersion, bool isInterceptor, address objectAddress, address initialOwner);
-    event LogRegistryServiceRegistered(VersionPart release, ObjectType domain);
+    event LogRegistryObjectRegistered(NftId nftId, NftId parentNftId, ObjectType objectType, bool isInterceptor, address objectAddress, address initialOwner);
+    event LogRegistryServiceRegistered(NftId nftId, VersionPart majorVersion, ObjectType domain);
     event LogRegistryChainRegistryRegistered(NftId nftId, uint256 chainId, address chainRegistryAddress);
 
     // initialize
@@ -49,7 +49,6 @@ interface IRegistry is
     error ErrorRegistryCoreTypeRegistration();
 
     // _register()
-    error ErrorRegistryReleaseMismatch(VersionPart objectrelease, VersionPart parentRelease, VersionPart senderRelease);
     error ErrorRegistryGlobalRegistryAsParent(address objectAddress, ObjectType objectType);
     error ErrorRegistryTypeCombinationInvalid(address objectAddress, ObjectType objectType, ObjectType parentType);
     error ErrorRegistryContractAlreadyRegistered(address objectAddress);
@@ -59,10 +58,13 @@ interface IRegistry is
         NftId nftId;
         NftId parentNftId;
         ObjectType objectType;
-        VersionPart release;
         bool isInterceptor;
         // slot 1
         address objectAddress;
+        // slot 2
+        address initialOwner;
+        // slot 3
+        bytes data;
     }
 
     /// @dev Registers a registry contract for a specified chain.
@@ -70,30 +72,28 @@ interface IRegistry is
     function registerRegistry(
         NftId nftId, 
         uint256 chainId, 
-        address chainRegistryAddress,
-        VersionPart release
+        address chainRegistryAddress
     ) external;
 
     /// @dev Register a service with using the provided domain and version.
     /// The function returns a newly minted service NFT ID.
     /// May only be used to register services.
     function registerService(
-        ObjectInfo memory info,
-        address initialOwner,
-        ObjectType domain,
-        bytes memory data
+        ObjectInfo memory serviceInfo, 
+        VersionPart serviceVersion, 
+        ObjectType serviceDomain
     ) external returns(NftId nftId);
 
     /// @dev Register an object with a known core type.
     /// The function returns a newly minted object NFT ID.
     /// May not be used to register services.
-    function register(ObjectInfo memory info, address initialOwner, bytes memory data) external returns (NftId nftId);
+    function register(ObjectInfo memory info) external returns (NftId nftId);
 
     /// @dev Register an object with a custom type.
     /// The function returns a newly minted object NFT ID.
     /// This function is reserved for GIF releases > 3.
     /// May not be used to register known core types.
-    function registerWithCustomType(ObjectInfo memory info, address initialOwner, bytes memory data) external returns (NftId nftId);
+    function registerWithCustomType(ObjectInfo memory info) external returns (NftId nftId);
 
     function getInitialRelease() external view returns (VersionPart);
 
@@ -126,15 +126,9 @@ interface IRegistry is
 
     function getParentNftId(NftId nftId) external view returns (NftId parentNftId);
 
-    function getObjectData(NftId nftId) external view returns (bytes memory data);
+    function isObjectType(NftId nftId, ObjectType expectedObjectType) external view returns (bool);
 
-    function getObjectData(address objectAddress) external view returns (bytes memory data);
-
-    function isObjectType(NftId nftId, ObjectType expectedObjectType, VersionPart expectedRelease) external view returns (bool);
-
-    function isObjectType(address contractAddress, ObjectType expectedObjectType, VersionPart expectedRelease) external view returns (bool);
-
-    function getObjectRelease(NftId nftId) external view returns (VersionPart release);
+    function isObjectType(address contractAddress, ObjectType expectedObjectType) external view returns (bool);
 
     function getObjectAddress(NftId nftId) external view returns (address objectAddress);
 

package/contracts/registry/IRegistryService.sol

@@ -19,12 +19,13 @@ interface IRegistryService is
 {
      error ErrorRegistryServiceNotRegistryOwner();
 
-     // _checkInterface()
-     error ErrorRegistryServiceNotContract(address notContract);
-     error ErrorRegistryServiceInterfaceNotSupported(address registerable, bytes4 interfaceId);
+     error ErrorRegistryServiceNotService(address notService);
+     error ErrorRegistryServiceNotInstance(address notInstance);
+     error ErrorRegistryServiceNotProduct(address notProduct);
+     error ErrorRegistryServiceNotComponent(address notComponent);
+     error ErrorRegistryServiceNotProductLinkedComponent(address notProductLinkedComponent);
 
      error ErrorRegistryServiceRegisterableAddressInvalid(IRegisterable registerable, address found);
-     error ErrorRegistryServiceRegisterableParentInvalid(IRegisterable registerable, NftId expected, NftId found);
      error ErrorRegistryServiceRegisterableTypeInvalid(IRegisterable registerable, ObjectType expected, ObjectType found);
      error ErrorRegistryServiceRegisterableOwnerInvalid(IRegisterable registerable, address expected, address found);
      error ErrorRegistryServiceRegisterableOwnerZero(IRegisterable registerable);   
@@ -39,20 +40,23 @@ interface IRegistryService is
      error ErrorRegistryServiceInvalidInitialOwner(address initialOwner);
      error ErrorRegistryServiceInvalidAddress(address registerableAddress);
 
-     function registerStake(IRegistry.ObjectInfo memory info, address initialOwner, bytes memory data)
+     function registerStake(IRegistry.ObjectInfo memory info)
           external returns(NftId nftId); 
 
-     function registerInstance(IRegisterable instance, address initialOwner)
+     function registerInstance(IRegisterable instance, address owner)
           external returns(IRegistry.ObjectInfo memory info); 
 
-     function registerComponent(IRegisterable component, NftId parenNftId, ObjectType componentType, address initialOwner)
+     function registerProduct(IComponent product, address owner)
           external returns(IRegistry.ObjectInfo memory info);
 
-     function registerDistributor(IRegistry.ObjectInfo memory info, address initialOwner, bytes memory data) external returns(NftId nftId);
+     function registerProductLinkedComponent(IComponent component, ObjectType objectType, address owner)
+          external returns(IRegistry.ObjectInfo memory info);
+
+     function registerDistributor(IRegistry.ObjectInfo memory info) external returns(NftId nftId);
 
-     function registerPolicy(IRegistry.ObjectInfo memory info, address initialOwner, bytes memory data) external returns(NftId nftId);
+     function registerPolicy(IRegistry.ObjectInfo memory info) external returns(NftId nftId);
 
-     function registerBundle(IRegistry.ObjectInfo memory info, address initialOwner, bytes memory data) external returns(NftId nftId); 
+     function registerBundle(IRegistry.ObjectInfo memory info) external returns(NftId nftId); 
 
 }
 

package/contracts/registry/IRelease.sol

@@ -23,4 +23,7 @@ interface IRelease {
         bytes32 salt;
     }
 
+    /// @dev Registers a registry contract for a specified chain.
+    /// Only one chain registry may be registered per chain
+    function getRelease() external view returns (VersionPart release);
 }

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";
 
@@ -16,10 +15,7 @@ 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 +29,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
@@ -77,9 +66,8 @@ contract Registry is
     mapping(uint256 chainId => NftId registryNftId) private _registryNftIdByChainId;
     uint256[] 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
@@ -156,8 +144,7 @@ contract Registry is
     function registerRegistry(
         NftId nftId,
         uint256 chainId, 
-        address registryAddress,
-        VersionPart release
+        address registryAddress
     )
         external
         restricted()
@@ -191,19 +178,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 +204,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 +219,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 +266,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 +293,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
@@ -404,20 +364,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 +381,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 +439,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 +452,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 +559,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
@@ -630,9 +584,10 @@ contract Registry is
                 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
@@ -648,9 +603,10 @@ contract Registry is
                     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);
         }
     }
@@ -674,7 +630,6 @@ contract Registry is
         // register the registry info
         _registerForNft(
             info,
-            NFT_LOCK_ADDRESS, // initial owner of any registry
             updateAddressLookup); 
     }
 
@@ -692,10 +647,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 +658,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 +670,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

@@ -11,8 +11,8 @@ 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
@@ -52,6 +52,7 @@ contract RegistryAdmin is
     // completeSetup
     error ErrorRegistryAdminNotRegistry(address registry);
 
+    address internal _registry;
     address private _releaseRegistry;
     address private _tokenRegistry;
     address private _staking;
@@ -61,40 +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
+        AccessAdminLib.checkRegistry(registry);
+
+        AccessManagerCloneable(
+            authority()).completeSetup(
+                registry, 
+                release); 
+
         AccessAdminLib.checkAuthorization(
             address(_authorization),
             authorization, 
             REGISTRY(), 
-            getRelease(), 
+            release, 
             false, // expectServiceAuthorization
             false); // checkAlreadyInitialized);
-        
-        // effects
+
+        _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);
 
@@ -139,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);