@etherisc/gif-next 0.0.2-78bf628-134 → 0.0.2-790d44b-698

package/contracts/registry/Registry.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
 import {IRegisterable} from "../shared/IRegisterable.sol";
 import {IService} from "../instance/base/IService.sol";
@@ -8,11 +8,14 @@ import {IChainNft} from "./IChainNft.sol";
 import {ChainNft} from "./ChainNft.sol";
 import {IRegistry} from "./IRegistry.sol";
 import {NftId, toNftId, zeroNftId, NftIdLib} from "../types/NftId.sol";
-import {VersionPart} from "../types/Version.sol";
-import {ObjectType, PROTOCOL, REGISTRY, TOKEN, SERVICE, INSTANCE, STAKE, PRODUCT, COMPENSATION, ORACLE, POOL, POLICY, BUNDLE} from "../types/ObjectType.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
+import {ObjectType, PROTOCOL, REGISTRY, TOKEN, SERVICE, INSTANCE, STAKE, PRODUCT, DISTRIBUTION, ORACLE, POOL, POLICY, BUNDLE} from "../types/ObjectType.sol";
+
+import {Versionable} from "../shared/Versionable.sol";
+
 
-// TODO make registry upgradable
 contract Registry is
+    Versionable,
     IRegisterable,
     IRegistry
 {
@@ -20,62 +23,84 @@ contract Registry is
 
     string public constant EMPTY_URI = "";
 
-    mapping(NftId nftId => ObjectInfo info) private _info;
-    mapping(NftId nftId => address owner) private _owner;
-    mapping(address object => NftId nftId) private _nftIdByAddress;
-    mapping(ObjectType objectType => bool) private _isValidType;
-    mapping(ObjectType objectType => mapping(ObjectType objectParentType => bool)) private _isValidParentType;
+    // IMPORTANT Every new version with storage changes must implement its own struct
+    // copy paste previous version and add changes
+    // @custom:storage-location erc7201:gif-next.contracts.registry.Registry.sol
+    struct StorageV1 {
+
+        mapping(NftId nftId => ObjectInfo info) _info;
+        mapping(address object => NftId nftId) _nftIdByAddress;
+        mapping(ObjectType objectType => bool) _isValidType;
+        mapping(ObjectType objectType => mapping(ObjectType objectParentType => bool)) _isValidParentType;
 
-    mapping(NftId nftId => string stringValue) private _string;
-    mapping(bytes32 serviceNameHash => mapping(VersionPart majorVersion => address service)) _service;
+        mapping(NftId nftId => string stringValue) _string;
+        mapping(bytes32 serviceNameHash => mapping(VersionPart majorVersion => address service)) _service;
 
-    NftId private _nftId;
-    IChainNft private _chainNft;
-    ChainNft private _chainNftInternal;
-    address private _initialOwner;
+        NftId _nftId;
+        IChainNft _chainNft;
+        ChainNft _chainNftInternal;
+        address _initialOwner;
 
-    // @dev will own protocol nft and registry nft(s) minted during initialize
-    address private _protocolOwner;
+        /// @dev will own protocol nft and registry nft(s) minted during initialize
+        address _protocolOwner;
+        // if struct goes here
+        // then you cannot add new vars here
+    }
 
-    // TODO refactor once registry becomes upgradable
-    // @Dev the protocol owner will get ownership of the
+    // TODO do not use gif-next in namespace id
+    // TODO ask openzeppelin about public location
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.registry.Registry.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant LOCATION_V1 = 0x6548007c3f4340f82f348c576c0ff69f4f529cadd5ad41f96aae61abceeaa300;
+
+    // TODO check how usage of "$.data" influences gas costs 
+    // IMPORTANT Every new version must implement this function
+    // keep it private -> if unreachable from the next version then not included in its byte code
+    // each version MUST use the same locationV1, just change return type
+    function _getStorage() private pure returns (StorageV1 storage $) {
+        assembly {
+            $.slot := LOCATION_V1
+        }
+    }
+
+    /// @dev the protocol owner will get ownership of the
     // protocol nft and the global registry nft minted in this 
     // initializer function 
-    function initialize(
-        address chainNft, 
-        address protocolOwner
-    )
-        public 
+    function _initialize(bytes memory data) 
+        internal
+        onlyInitializing
+        virtual override
     {
-        require(
-            address(_chainNft) == address(0),
-            "ERROR:REG-001:ALREADY_INITIALIZED"
-        );
-
-        _initialOwner = msg.sender;
-        _protocolOwner = protocolOwner;
-
-        _chainNft = IChainNft(chainNft);
-        _chainNftInternal = ChainNft(chainNft);
-
+        address protocolOwner = abi.decode(data, (address));
+        StorageV1 storage $ = _getStorage();
+
+         // TODO here delegate call from proxy constructor, msg.sender is proxy deployer -> Proxy.sol
+        $._initialOwner = msg.sender;
+        $._protocolOwner = protocolOwner;
+
+        // TODO deployment size is to big, call another contract which keeps and deploys ChainNft byte code  
+        // deploy NFT 
+        $._chainNftInternal = new ChainNft(address(this));// adds 10kb to deployment size
+        $._chainNft = IChainNft($._chainNftInternal);
+        
         // initial registry setup
         _registerProtocol();
-        _nftId = _registerRegistry();
+        $._nftId = _registerRegistry();
 
         // setup rules for further registrations
         _setupValidTypes();
         _setupValidParentTypes();
     }
 
-
     function register(
         address objectAddress
     )
     // TODO add authz (only services may register components etc)
     // we have to check how we do authz for registring services (just restrict to protocol owner/registry owner)
     external override returns (NftId nftId) {
+        StorageV1 storage $ = _getStorage();
+
         require(
-            _nftIdByAddress[objectAddress].eqz(),
+            $._nftIdByAddress[objectAddress].eqz(),
             "ERROR:REG-002:ALREADY_REGISTERED"
         );
 
@@ -87,7 +112,7 @@ contract Registry is
 
         ObjectType objectType = registerable.getType();
         require(
-            _isValidType[objectType],
+            $._isValidType[objectType],
             "ERROR:REG-004:TYPE_INVALID"
         );
 
@@ -98,14 +123,14 @@ contract Registry is
         );
 
         require(
-            _isValidParentType[objectType][_info[parentNftId].objectType],
+            $._isValidParentType[objectType][$._info[parentNftId].objectType],
             "ERROR:REG-006:PARENT_TYPE_INVALID"
         );
 
         // also check that nftId and parentNFtId are on the same chain if applicable
 
         // nft minting
-        uint256 mintedTokenId = _chainNft.mint(
+        uint256 mintedTokenId = $._chainNft.mint(
             registerable.getOwner(),
             EMPTY_URI
         );
@@ -125,13 +150,13 @@ contract Registry is
             bytes32 serviceNameHash = keccak256(abi.encode(serviceName));
 
             // service specific state
-            _string[nftId] = serviceName;
+            $._string[nftId] = serviceName;
 
             require(
-                _service[serviceNameHash][majorVersion] == address(0),
+                $._service[serviceNameHash][majorVersion] == address(0),
                 "ERROR:REG-008:ALREADY_REGISTERED"
             );
-            _service[serviceNameHash][majorVersion] = objectAddress;
+            $._service[serviceNameHash][majorVersion] = objectAddress;
         }
 
         // create object info and link nft id with it
@@ -152,13 +177,15 @@ contract Registry is
             NftId nftId
         )
     {
+        StorageV1 storage $ = _getStorage();
+
         // TODO add more validation
         require(
             objectType == POLICY() || objectType == BUNDLE(),
             "ERROR:REG-010:TYPE_INVALID"
         );
 
-        uint256 mintedTokenId = _chainNft.mint(initialOwner, EMPTY_URI);
+        uint256 mintedTokenId = $._chainNft.mint(initialOwner, EMPTY_URI);
         nftId = toNftId(mintedTokenId);
 
         ObjectInfo memory info = ObjectInfo(
@@ -170,57 +197,57 @@ contract Registry is
             data
         );
 
-        _info[nftId] = info;
+        $._info[nftId] = info;
 
         // add logging
     }
 
     function getObjectCount() external view override returns (uint256) {
-        return _chainNft.totalSupply();
+        return _getStorage()._chainNft.totalSupply();
     }
 
     function getNftId(
         address object
     ) external view override returns (NftId id) {
-        return _nftIdByAddress[object];
+        return _getStorage()._nftIdByAddress[object];
     }
 
     function isRegistered(
         NftId nftId
     ) public view override returns (bool) {
-        return _info[nftId].objectType.gtz();
+        return _getStorage()._info[nftId].objectType.gtz();
     }
 
     function isRegistered(
         address object
     ) external view override returns (bool) {
-        return _nftIdByAddress[object].gtz();
+        return _getStorage()._nftIdByAddress[object].gtz();
     }
 
     function getObjectInfo(
         NftId nftId
     ) external view override returns (ObjectInfo memory info) {
-        return _info[nftId];
+        return _getStorage()._info[nftId];
     }
 
     function getName(
         NftId nftId
     ) external view returns (string memory name) {
-        return _string[nftId];
+        return _getStorage()._string[nftId];
     }
 
     function getOwner(NftId nftId) external view override returns (address) {
-        return _chainNft.ownerOf(nftId.toInt());
+        return _getStorage()._chainNft.ownerOf(nftId.toInt());
     }
 
     function getChainNft() external view override returns (IChainNft) {
-        return _chainNft;
+        return _getStorage()._chainNft;
     }
 
     // special case to retrive a gif service
     function getServiceAddress(string memory serviceName, VersionPart majorVersion) external view override returns (address serviceAddress) {
         bytes32 serviceNameHash = keccak256(abi.encode(serviceName));
-        return _service[serviceNameHash][majorVersion];
+        return _getStorage()._service[serviceNameHash][majorVersion];
     }
 
     // from IERC165
@@ -233,7 +260,16 @@ contract Registry is
         return this;
     }
 
+    // from IVersionable
+    function getVersion() public pure virtual override returns (Version) {
+        return VersionLib.toVersion(1, 0, 0);
+    } 
+
     // from IRegisterable
+    // TODO 
+    // 1) Registerable can not register itself -> otherwise register have to trust owner address provided by registerable
+    // registerable owner MUST call register and provide registerable address
+    // 2) Who is msg.sender here???
     function register() external pure override returns (NftId nftId) {
         return zeroNftId();
     }
@@ -242,73 +278,77 @@ contract Registry is
         return REGISTRY();
     }
 
-
     function getOwner() public view override returns (address owner) {
-        return _nftId.gtz() ? this.getOwner(_nftId) : _initialOwner;
+        StorageV1 storage $ = _getStorage();
+        return $._nftId.gtz() ? this.getOwner($._nftId) : $._initialOwner;
     }
 
-    function getNftId() external view override (IRegisterable, IRegistry) returns (NftId nftId) {
-        return _nftId;
+    function getNftId() public view override (IRegisterable, IRegistry) returns (NftId nftId) {
+        return _getStorage()._nftId;
     }
 
-    function getParentNftId() external view returns (NftId nftId) {
-        // we're the global registry
-        if(block.chainid == 1) {
-            return toNftId(_chainNftInternal.PROTOCOL_NFT_ID());
-        }
-        else {
-            return toNftId(_chainNftInternal.GLOBAL_REGISTRY_ID());
-        }
+    function getParentNftId() public view returns (NftId nftId) {
+        StorageV1 storage $ = _getStorage();
+        nftId = $._info[$._nftId].parentNftId;
     }
 
-    function getData() external pure returns (bytes memory data) {
+    function getData() public pure returns (bytes memory data) {
         return "";
     }
 
     // registry specific functions
     function getProtocolOwner() external view override returns (address) {
-        return _protocolOwner;
+        return _getStorage()._protocolOwner;
     }
 
     /// @dev defines which types are allowed to register
-    function _setupValidTypes() internal {
-        _isValidType[REGISTRY()] = true; // only for global registry 
-        _isValidType[TOKEN()] = true;
-        _isValidType[SERVICE()] = true;
-        _isValidType[INSTANCE()] = true;
-        _isValidType[STAKE()] = true;
-        _isValidType[PRODUCT()] = true;
-        _isValidType[ORACLE()] = true;
-        _isValidType[POOL()] = true;
-        _isValidType[POLICY()] = true;
-        _isValidType[BUNDLE()] = true;
+    function _setupValidTypes() internal onlyInitializing {
+        StorageV1 storage $ = _getStorage();
+        $._isValidType[REGISTRY()] = true; // only for global registry 
+        $._isValidType[TOKEN()] = true;
+        $._isValidType[SERVICE()] = true;
+        $._isValidType[INSTANCE()] = true;
+        $._isValidType[STAKE()] = true;
+        $._isValidType[PRODUCT()] = true;
+        $._isValidType[ORACLE()] = true;
+        $._isValidType[POOL()] = true;
+        $._isValidType[DISTRIBUTION()] = true;
+        $._isValidType[POLICY()] = true;
+        $._isValidType[BUNDLE()] = true;
     }
 
     /// @dev defines which types - parent type relations are allowed to register
-    function _setupValidParentTypes() internal {
+    function _setupValidParentTypes() internal onlyInitializing {
+        StorageV1 storage $ = _getStorage();
         // registry as parent
-        _isValidParentType[TOKEN()][REGISTRY()] = true;
-        _isValidParentType[SERVICE()][REGISTRY()] = true;
-        _isValidParentType[INSTANCE()][REGISTRY()] = true;
+        $._isValidParentType[TOKEN()][REGISTRY()] = true;
+        $._isValidParentType[SERVICE()][REGISTRY()] = true;
+        $._isValidParentType[INSTANCE()][REGISTRY()] = true;
 
         // instance as parent
-        _isValidParentType[PRODUCT()][INSTANCE()] = true;
-        _isValidParentType[COMPENSATION()][INSTANCE()] = true;
-        _isValidParentType[ORACLE()][INSTANCE()] = true;
-        _isValidParentType[POOL()][INSTANCE()] = true;
+        $._isValidParentType[PRODUCT()][INSTANCE()] = true;
+        $._isValidParentType[DISTRIBUTION()][INSTANCE()] = true;
+        $._isValidParentType[ORACLE()][INSTANCE()] = true;
+        $._isValidParentType[POOL()][INSTANCE()] = true;
 
         // product as parent
-        _isValidParentType[POLICY()][PRODUCT()] = true;
+        $._isValidParentType[POLICY()][PRODUCT()] = true;
 
         // pool as parent
-        _isValidParentType[BUNDLE()][POOL()] = true;
-        _isValidParentType[STAKE()][POOL()] = true;
+        $._isValidParentType[BUNDLE()][POOL()] = true;
+        $._isValidParentType[STAKE()][POOL()] = true;
     }
 
     /// @dev protocol registration used to anchor the dip ecosystem relations
-    function _registerProtocol() virtual internal {
-        uint256 protocolId = _chainNftInternal.PROTOCOL_NFT_ID();
-        _chainNftInternal.mint(_protocolOwner, protocolId);
+    function _registerProtocol() 
+        virtual 
+        internal
+        onlyInitializing 
+    {
+        StorageV1 storage $ = _getStorage();
+
+        uint256 protocolId = $._chainNftInternal.PROTOCOL_NFT_ID();
+        $._chainNftInternal.mint($._protocolOwner, protocolId);
 
         NftId protocolNftid = toNftId(protocolId);
         ObjectInfo memory protocolInfo = ObjectInfo(
@@ -316,66 +356,103 @@ contract Registry is
             zeroNftId(), // parent nft id
             PROTOCOL(),
             address(0), // contract address
-            _protocolOwner,
+            $._protocolOwner,
             "" // data
         );
 
-        _info[protocolNftid] = protocolInfo;
+        $._info[protocolNftid] = protocolInfo;
     }
 
     /// @dev registry registration
     /// might also register the global registry when not on mainnet
-    function _registerRegistry() virtual internal returns (NftId registryNftId) {
-        uint256 registryId = _chainNftInternal.calculateTokenId(2);
+    function _registerRegistry() 
+        virtual 
+        internal
+        onlyInitializing 
+        returns (NftId registryNftId) 
+    {
+        StorageV1 storage $ = _getStorage();
+
+        uint256 registryId = $._chainNftInternal.calculateTokenId(2);
         registryNftId = toNftId(registryId);
 
         // we're not the global registry
-        if(registryId != _chainNftInternal.GLOBAL_REGISTRY_ID()) {
+        if(registryId != $._chainNftInternal.GLOBAL_REGISTRY_ID()) {
             _registerGlobalRegistry();
         }
 
-        _chainNftInternal.mint(_protocolOwner, registryId);
-        _registerObjectInfo(this, registryNftId);
+        $._chainNftInternal.mint($._protocolOwner, registryId);
+
+        NftId parentNftId;
+        // we're the global registry
+        if(block.chainid == 1) {
+            parentNftId = toNftId($._chainNftInternal.PROTOCOL_NFT_ID());
+        }
+        else {
+            parentNftId = toNftId($._chainNftInternal.GLOBAL_REGISTRY_ID());
+        }
+        ObjectInfo memory registryInfo = ObjectInfo(
+            registryNftId,
+            parentNftId,
+            REGISTRY(),
+            address(this),  // proxy address
+            $._protocolOwner, // registry owner is different from proxy owner 
+            ""
+        );
+
+        $._info[registryNftId] = registryInfo;
+        $._nftIdByAddress[address(this)] = registryNftId;
+
+        // add logging
     }
 
 
     /// @dev global registry registration for non mainnet registries
-    function _registerGlobalRegistry() virtual internal {
-        uint256 globalRegistryId = _chainNftInternal.GLOBAL_REGISTRY_ID();
-        _chainNftInternal.mint(_protocolOwner, globalRegistryId);
+    function _registerGlobalRegistry() 
+        virtual 
+        internal
+        onlyInitializing
+    {
+        StorageV1 storage $ = _getStorage();
+
+        uint256 globalRegistryId = $._chainNftInternal.GLOBAL_REGISTRY_ID();
+        $._chainNftInternal.mint($._protocolOwner, globalRegistryId);
 
         NftId globalRegistryNftId = toNftId(globalRegistryId);
         ObjectInfo memory globalRegistryInfo = ObjectInfo(
             globalRegistryNftId,
-            toNftId(_chainNftInternal.PROTOCOL_NFT_ID()),
+            toNftId($._chainNftInternal.PROTOCOL_NFT_ID()),
             REGISTRY(),
             address(0), // contract address
-            _protocolOwner,
+            $._protocolOwner,
             "" // data
         );
 
-        _info[globalRegistryNftId] = globalRegistryInfo;
+        $._info[globalRegistryNftId] = globalRegistryInfo;
     }
 
-
     function _registerObjectInfo(
         IRegisterable registerable,
         NftId nftId
-    ) internal virtual {
+    ) 
+        internal 
+        virtual
+    {
         address objectAddress = address(registerable);
         ObjectInfo memory info = ObjectInfo(
             nftId,
-            registerable.getParentNftId(),
+            registerable.getParentNftId(), 
             registerable.getType(),
             objectAddress,
             registerable.getOwner(),
             registerable.getData()
         );
 
-        _info[nftId] = info;
-        _nftIdByAddress[objectAddress] = nftId;
+        StorageV1 storage $ = _getStorage();
+        $._info[nftId] = info;
+        $._nftIdByAddress[objectAddress] = nftId;
 
         // add logging
     }
 
-}
+}

package/contracts/shared/IVersionable.sol

@@ -1,9 +1,37 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.19;
 
-import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
-import {Timestamp, blockTimestamp} from "../types/Timestamp.sol";
-import {Version, VersionPart} from "../types/Version.sol";
+import {Blocknumber} from "../types/Blocknumber.sol";
+import {Timestamp} from "../types/Timestamp.sol";
+import {Version} from "../types/Version.sol";
+
+
+/// IMPORTANT
+// Upgradeable contract MUST:
+// 1) inherit from Versionable
+// 2) implement version() function
+// 3) implement internal _initialize() function with onlyInitializing modifier 
+// 4) implement internal _upgrade() function with onlyInitializing modifier (1st version MUST revert)
+// 5) have onlyInitialising modifier for each function callable inside _initialize()/_upgrade() (MUST use different functions for initialization/upgrade and normal operations)
+// 6) use default empty constructor -> _disableInitializer() called from Versionable contructor
+// 7) use namespace storage
+//
+// IMPORTANT
+// Each version MUST:
+// 1) ALWAYS define namespace storage struct (even if no changes were introduced)
+//      - DO NOT use structs inside, except
+//      - CAN use structs ONLY inside mappings
+// 2) ALWAYS define private getter (even if no changes were introduced)
+//      - MUST use default implementation, CAN change ONLY return type
+//      - MUST use the same "LOCATION_V1"
+// Optional:
+// 4) implement public initialize() 
+//      - MUST use intializer modifier
+//      - MUST call Versionable._updateVersionHistory()
+// 5) implement public upgrade()
+//      - 1st version MUST revert
+//      - MUST use reinitializer(VersionLib.toUint64(getVersion())) modifier
+//      - MUST call Versionable._updateVersionHistory()
 
 interface IVersionable {
 
@@ -15,19 +43,30 @@ interface IVersionable {
         Blocknumber activatedIn;
     }
 
-    event LogVersionableActivated(Version version, address implementation, address activatedBy);
+    event LogVersionableInitialized(Version version, address implementation, address activatedBy);
+
+    // TODO uncomment when all implementations are ready
+    /**
+     * @dev IMPORTANT
+     * implementation MUST be guarded by initializer modifier
+     * implementation MUST call internal function Versionable._updateVersionHistory 
+     * new version MUST inherit from previous version
+     */
+    function initialize(address implementation, address activatedBy, bytes memory activationData) external;
 
     /**
-     * @dev IMPORTANT this function needs to be implemented by each new version
-     * any such activate implementation needs to call internal function call _activate() 
-     * any new version needs to inherit from previous version
+     * @dev
+     * implementation MUST be guarded by reinitializer(version().toUint64()) modifier
+     * implementation MUST call internal function Versionable._updateVersionHistory
+     * new version MUST inherit from previous version
+     * the first verion MUST revert 
      */
-    function activate(address implementation, address activatedBy) external;
+    function upgrade(address implementation, address activatedBy, bytes memory upgradeData) external;
 
     /**
      * @dev returns true if the specified version has been activated for the current contract
      */
-    function isActivated(Version version) external view returns(bool);
+    function isInitialized(Version version) external view returns(bool);
 
     /**
      * @dev returns currently active version of this contract
@@ -49,4 +88,7 @@ interface IVersionable {
      */
     function getVersionInfo(Version version) external view returns(VersionInfo memory versionInfo);
 
+    // TODO make sure it is needed here
+    function getInitializedVersion() external view returns(uint64);
+
 }