@etherisc/gif-next 0.0.2-bfb44e0-483 → 0.0.2-c0b400a-177

package/contracts/shared/IVersionable.sol

@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-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
@@ -14,7 +11,7 @@ import {Version} from "../types/Version.sol";
 // 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() is called from Versionable contructor
-// 7) use namespace storage
+// 7) use namespace storage (should this be needed)
 // 8) since now inheritance is used for upgradability, contract MUST BE inherited ONLY by the next version 
 // Upgradeable contract SHOULD:
 // 9) define all non private methods as virtual (in order to be able to upgrade them latter)
@@ -22,48 +19,29 @@ import {Version} from "../types/Version.sol";
 //    in some cases this ok but not in the others...
 //
 // IMPORTANT
-// Each version MUST:
+// If introducting/amending storage related to Versionable version MUST:
 // 1) define namespace storage struct if accessing storage
 //      - DO NOT use structs inside, except
 //      - CAN use structs ONLY inside mappings
 // 2) ALWAYS define private getter if accessing storage
 //      - MUST use default implementation, CAN change ONLY return type
-//      - MUST use the same "LOCATION_V1"
 
 interface IVersionable {
 
-    struct VersionInfo {
-        Version version;
-        address implementation;
-        address activatedBy;
-        Timestamp activatedAt;
-        Blocknumber activatedIn;
-    }
-
-    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 initializeVersionable(address implementation, address activatedBy, bytes memory activationData) external;
+    function initializeVersionable(address activatedBy, bytes memory activationData) external;
 
     /**
      * @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 upgradeVersionable(address implementation, address activatedBy, bytes memory upgradeData) external;
-
-    /**
-     * @dev returns true if the specified version has been activated for the current contract
-     */
-    function isInitialized(Version version) external view returns(bool);
+    function upgradeVersionable(bytes memory upgradeData) external;
 
     /**
      * @dev returns version of this contract
@@ -72,25 +50,4 @@ interface IVersionable {
      */
     function getVersion() external pure returns(Version);
 
-    /**
-     * @dev returns the number of all deployed versions of this contract
-     */
-    function getVersionCount() external view returns(uint256 numberOfVersions);
-
-    /**
-     * @dev returns the i-th (index) version of this contract
-     */
-    function getVersion(uint256 index) external view returns(Version version);
-
-    /**
-     * @dev returns the i-th (index) version info of this contract
-     */
-    function getVersionInfo(Version version) external view returns(VersionInfo memory versionInfo);
-
-    // TODO make sure it is needed here
-    /**
-     * @dev returns currently active version
-     */
-    function getInitializedVersion() external view returns(uint64);
-
 }

package/contracts/shared/NftOwnable.sol

@@ -5,8 +5,7 @@ pragma solidity ^0.8.20;
 
 import {ERC165} from "./ERC165.sol";
 import {INftOwnable} from "./INftOwnable.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId, zeroNftId} from "../types/NftId.sol";
+import {NftId} from "../types/NftId.sol";
 import {RegistryLinked} from "./RegistryLinked.sol";
 
 contract NftOwnable is
@@ -18,7 +17,6 @@ contract NftOwnable is
     bytes32 public constant NFT_OWNABLE_STORAGE_LOCATION_V1 = 0x07ebcf49758b6ed3af50fa146bec0abe157c0218fe65dc0874c286e9d5da4f00;
 
     struct NftOwnableStorage {
-        // IRegistry _registry;
         NftId _nftId;
         address _initialOwner; 
     }
@@ -26,7 +24,7 @@ contract NftOwnable is
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
     modifier onlyOwner() {
         if (msg.sender != getOwner()) {
-            revert ErrorNotOwner(msg.sender);
+            revert ErrorNftOwnableNotOwner(msg.sender);
         }
         _;
     }
@@ -42,21 +40,14 @@ contract NftOwnable is
         virtual
         onlyInitializing()
     {
-        _setInitialOwner(initialOwner);
-
         initializeRegistryLinked(registryAddress);
         initializeERC165();
-        registerInterface(type(INftOwnable).interfaceId);
-    }
 
+        if(initialOwner == address(0)) {
+            revert ErrorNftOwnableInitialOwnerZero();
+        }
 
-    function initializeOwner(address initialOwner)
-        public
-        initializer()
-    {
-        _setInitialOwner(initialOwner);
-        initializeERC165();
-        registerInterface(type(INftOwnable).interfaceId);
+        _getNftOwnableStorage()._initialOwner = initialOwner;
     }
 
 
@@ -71,35 +62,22 @@ contract NftOwnable is
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
         if ($._nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(getRegistry()), $._nftId);
-        }
-
-        if (address(getRegistry()) == address(0)) {
-            revert ErrorRegistryNotInitialized();
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
         address contractAddress = address(this);
 
         if (!getRegistry().isRegistered(contractAddress)) {
-            revert ErrorContractNotRegistered(contractAddress);
+            revert ErrorNftOwnableContractNotRegistered(contractAddress);
         }
 
         $._nftId = getRegistry().getNftId(contractAddress);
     }
 
-
-    // function getRegistry() public view virtual override returns (IRegistry) {
-    //     return _getNftOwnableStorage()._registry;
-    // }
-
     function getNftId() public view virtual override returns (NftId) {
         return _getNftOwnableStorage()._nftId;
     }
 
-    function getInitialOwner() public view returns (address) {
-        return _getNftOwnableStorage()._initialOwner;
-    }
-
     function getOwner() public view virtual override returns (address) {
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
@@ -110,41 +88,22 @@ contract NftOwnable is
         return $._initialOwner;
     }
 
-    /// @dev set initialOwner
-    /// initial owner may only be set during initialization
-    function _setInitialOwner(address initialOwner)
-        internal
-        virtual
-        onlyInitializing()
-    {
-        if(initialOwner == address(0)) {
-            revert ErrorInitialOwnerZero();
-        }
-
-        _getNftOwnableStorage()._initialOwner = initialOwner;
-    }
-
-    // TODO check if function can be refactored to work with a registry address set in an initializer
     /// @dev used in constructor of registry service manager
     // links ownership of registry service manager ot nft owner of registry service
     function _linkToNftOwnable(
-        address registryAddress,
         address nftOwnableAddress
     )
         internal
-        onlyOwner()
         returns (NftId)
     {
         NftOwnableStorage storage $ = _getNftOwnableStorage();
 
         if ($._nftId.gtz()) {
-            revert ErrorAlreadyLinked(address(getRegistry()), $._nftId);
+            revert ErrorNftOwnableAlreadyLinked($._nftId);
         }
 
-        _setRegistry(registryAddress);
-
         if (!getRegistry().isRegistered(nftOwnableAddress)) {
-            revert ErrorContractNotRegistered(nftOwnableAddress);
+            revert ErrorNftOwnableContractNotRegistered(nftOwnableAddress);
         }
 
         $._nftId = getRegistry().getNftId(nftOwnableAddress);
@@ -153,35 +112,6 @@ contract NftOwnable is
     }
 
 
-    // function _setRegistry(address registryAddress)
-    //     private
-    // {
-    //     NftOwnableStorage storage $ = _getNftOwnableStorage();
-
-    //     if (address($._registry) != address(0)) {
-    //         revert ErrorRegistryAlreadyInitialized(address($._registry));
-    //     }
-
-    //     if (registryAddress == address(0)) {
-    //         revert ErrorRegistryAddressZero();
-    //     }
-
-    //     if (registryAddress.code.length == 0) {
-    //         revert ErrorNotRegistry(registryAddress);
-    //     }
-
-    //     $._registry = IRegistry(registryAddress);
-
-    //     try $._registry.supportsInterface(type(IRegistry).interfaceId) returns (bool isRegistry) {
-    //         if (!isRegistry) {
-    //             revert ErrorNotRegistry(registryAddress);
-    //         }
-    //     } catch {
-    //         revert ErrorNotRegistry(registryAddress);
-    //     }
-    // }
-
-
     function _getNftOwnableStorage() private pure returns (NftOwnableStorage storage $) {
         assembly {
             $.slot := NFT_OWNABLE_STORAGE_LOCATION_V1

package/contracts/shared/ProxyManager.sol

@@ -1,34 +1,56 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
 
+import {Blocknumber, blockNumber} from "../types/Blocknumber.sol";
 import {IVersionable} from "./IVersionable.sol";
 import {NftOwnable} from "./NftOwnable.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Timestamp, TimestampLib} from "../types/Timestamp.sol";
 import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.sol";
+import {Version, VersionLib} from "../types/Version.sol";
 
 /// @dev manages proxy deployments for upgradable contracs of type IVersionable
 contract ProxyManager is
     NftOwnable
 {
 
-    event LogProxyDeployed(address indexed proxy, address initialImplementation);
-    event LogProxyDeployedWithSalt(address indexed proxy, address initialImplementation);
-    event LogProxyUpgraded(address indexed proxy, address upgradedImplementation);
+    struct VersionInfo {
+        Version version;
+        address implementation;
+        address activatedBy;
+        Timestamp activatedAt;
+        Blocknumber activatedIn;
+    }
+
+    event LogProxyManagerVersionableDeployed(address indexed proxy, address initialImplementation);
+    event LogProxyManagerVersionableUpgraded(address indexed proxy, address upgradedImplementation);
 
-    error ErrorAlreadyDeployed();
-    error ErrorAlreadyDeployedWithSalt();
-    error ErrorNotYetDeployed();
+    error ErrorProxyManagerAlreadyDeployed();
+    error ErrorProxyManagerNotYetDeployed();
+
+    error ErrorProxyManagerZeroVersion();
+    error ErrorProxyManagerNextVersionNotIncreasing(Version nextVersion);
 
     UpgradableProxyWithAdmin internal _proxy;
-    bool internal _isDeployed;
+
+    // state to keep version history
+    mapping(Version version => VersionInfo info) _versionHistory;
+    Version [] _versions;
 
     /// @dev only used to capture proxy owner
-    constructor()
+    constructor(address registry)
     { 
-        initializeOwner(msg.sender);
+        initializeProxyManager(registry);
+    }
+
+    function initializeProxyManager(address registry)
+        public
+        initializer()
+    {
+        initializeNftOwnable(msg.sender, registry);
     }
 
     /// @dev deploy initial contract
@@ -38,22 +60,23 @@ contract ProxyManager is
         onlyOwner()
         returns (IVersionable versionable)
     {
-        if (_isDeployed) { revert ErrorAlreadyDeployed(); }
-        _isDeployed = true;
+        if (_versions.length > 0) {
+            revert ErrorProxyManagerAlreadyDeployed();
+        }
 
         address currentProxyOwner = getOwner(); // used by implementation
         address initialProxyAdminOwner = address(this); // used by proxy
-        bytes memory data = getDeployData(initialImplementation, currentProxyOwner, initializationData);
         
         _proxy = new UpgradableProxyWithAdmin(
             initialImplementation,
             initialProxyAdminOwner,
-            data
+            getDeployData(currentProxyOwner, initializationData)
         );
 
         versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), initialImplementation, currentProxyOwner);
 
-        emit LogProxyDeployed(address(_proxy), initialImplementation);
+        emit LogProxyManagerVersionableDeployed(address(_proxy), initialImplementation);
     }
 
     /// @dev upgrade existing contract
@@ -63,33 +86,84 @@ contract ProxyManager is
         onlyOwner()
         returns (IVersionable versionable)
     {
-        if (!_isDeployed) { revert ErrorNotYetDeployed(); }
+        if (_versions.length == 0) { 
+            revert ErrorProxyManagerNotYetDeployed();
+        }
 
         address currentProxyOwner = getOwner();
         ProxyAdmin proxyAdmin = getProxy().getProxyAdmin();
         ITransparentUpgradeableProxy proxy = ITransparentUpgradeableProxy(address(_proxy));
-        bytes memory data = getUpgradeData(newImplementation, currentProxyOwner, upgradeData);
 
         proxyAdmin.upgradeAndCall(
             proxy,
             newImplementation, 
-            data);
+            getUpgradeData(upgradeData));
 
         versionable = IVersionable(address(_proxy));
+        _updateVersionHistory(versionable.getVersion(), newImplementation, currentProxyOwner);
 
-        emit LogProxyUpgraded(address(_proxy), newImplementation);
+        emit LogProxyManagerVersionableUpgraded(address(_proxy), newImplementation);
 
     }
 
-    function getDeployData(address implementation, address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
-        return abi.encodeWithSelector(IVersionable.initializeVersionable.selector, implementation, proxyOwner, deployData);
+    function getDeployData(address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(
+            IVersionable.initializeVersionable.selector, 
+            proxyOwner, 
+            deployData);
     }
 
-    function getUpgradeData(address implementation, address proxyOwner, bytes memory upgradeData) public pure returns (bytes memory data) {
-        return abi.encodeWithSelector(IVersionable.upgradeVersionable.selector, implementation, proxyOwner, upgradeData);
+    function getUpgradeData(bytes memory upgradeData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(
+            IVersionable.upgradeVersionable.selector, 
+            upgradeData);
     }
 
     function getProxy() public returns (UpgradableProxyWithAdmin) {
         return _proxy;
     }
+
+    function getVersion() external view virtual returns(Version) {
+        return IVersionable(address(_proxy)).getVersion();
+    }
+
+    function getVersionCount() external view returns(uint256) {
+        return _versions.length;
+    }
+
+    function getVersion(uint256 idx) external view returns(Version) {
+        return _versions[idx];
+    }
+
+    function getVersionInfo(Version _version) external view returns(VersionInfo memory) {
+        return _versionHistory[_version];
+    }
+
+    function _updateVersionHistory(
+        Version newVersion,
+        address implementation,
+        address activatedBy
+    )
+        private
+    {
+        if(newVersion == VersionLib.zeroVersion()) {
+            revert ErrorProxyManagerZeroVersion();
+        }
+
+        if(_versions.length > 0) {
+            if(newVersion.toInt() <= _versions[_versions.length-1].toInt()) {
+                revert ErrorProxyManagerNextVersionNotIncreasing(newVersion);
+            }
+        }
+
+        // update version history
+        _versions.push(newVersion);
+        _versionHistory[newVersion] = VersionInfo(
+            newVersion,
+            implementation,
+            activatedBy,
+            TimestampLib.blockTimestamp(),
+            blockNumber()
+        );
+    }
 }

package/contracts/shared/Registerable.sol

@@ -18,8 +18,6 @@ contract Registerable is
     // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Registerable.sol")) - 1)) & ~bytes32(uint256(0xff));
     bytes32 public constant REGISTERABLE_LOCATION_V1 = 0x6548007c3f4340f82f348c576c0ff69f4f529cadd5ad41f96aae61abceeaa300;
 
-    error ErrorRegisterableNotRegistry(address registryAddress);
-
     struct RegisterableStorage {
         NftId _parentNftId;
         ObjectType _objectType;
@@ -39,7 +37,7 @@ contract Registerable is
         ObjectType objectType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory data
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
     )
         public
         virtual
@@ -49,16 +47,11 @@ contract Registerable is
             initialOwner,
             registryAddress);
 
-        // TODO check parentNftId -> registry.isRegistered(parentNftId)
-        // TODO check object-parent type pair -> registry.isValidTypeCombo() or something...verify with registry that setup will be able to register...
-
         RegisterableStorage storage $ = _getRegisterableStorage();
         $._parentNftId = parentNftId;
         $._objectType = objectType;
         $._isInterceptor = isInterceptor;
-        $._data = data;
-
-        registerInterface(type(IRegisterable).interfaceId);
+        $._data = registryData;
     }
 
 
@@ -75,7 +68,7 @@ contract Registerable is
             $._objectType,
             $._isInterceptor,
             address(this), 
-            getInitialOwner(),
+            getOwner(),
             $._data);
     }
 }

package/contracts/shared/RegistryLinked.sol

@@ -21,32 +21,6 @@ contract RegistryLinked is
         virtual
         onlyInitializing()
     {
-        _setRegistry(registryAddress);
-    }
-
-
-    function getRegistry() public view returns (IRegistry) {
-        return _registry;
-    }
-
-
-    function getRegistryAddress() public view returns (address) {
-        return address(_registry);
-    }
-
-
-    function _setRegistry(address registryAddress)
-        internal
-    {
-
-        if (address(_registry) != address(0)) {
-            revert ErrorRegistryAlreadyInitialized(address(_registry));
-        }
-
-        if (registryAddress == address(0)) {
-            revert ErrorRegistryAddressZero();
-        }
-
         if (registryAddress.code.length == 0) {
             revert ErrorNotRegistry(registryAddress);
         }
@@ -61,4 +35,14 @@ contract RegistryLinked is
             revert ErrorNotRegistry(registryAddress);
         }
     }
+
+
+    function getRegistry() public view returns (IRegistry) {
+        return _registry;
+    }
+
+
+    function getRegistryAddress() public view returns (address) {
+        return address(_registry);
+    }
 }

package/contracts/shared/Service.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.19;
 
 import {ObjectType, SERVICE} from "../types/ObjectType.sol";
 import {NftId, zeroNftId} from "../types/NftId.sol";
-import {Version, VersionPart, VersionLib} from "../types/Version.sol";
+import {Version, VersionPart, VersionLib, VersionPartLib} from "../types/Version.sol";
 
 import {Versionable} from "./Versionable.sol";
 import {IService} from "./IService.sol";
@@ -22,8 +22,9 @@ abstract contract Service is
 {
     function getDomain() public pure virtual override returns(ObjectType);
 
+    // version major version MUST be consistent with major version of getVersion()
     function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
-        return getVersion().toMajorPart(); 
+        return VersionPartLib.toVersionPart(3); 
     }
 
     // from Versionable
@@ -44,17 +45,14 @@ abstract contract Service is
         virtual
         onlyInitializing()
     {
-        // service must provide its name and version upon registration
-        bytes memory data = abi.encode(getDomain(), getMajorVersion());
-        NftId registryNftId = _getRegistryNftId(registry); 
-        bool isInterceptor = false;
+        initializeRegisterable(
+            registry, 
+            IRegistry(registry).getNftId(), 
+            SERVICE(), 
+            false, // is interceptor
+            initialOwner, 
+            ""); // data
 
-        initializeRegisterable(registry, registryNftId, SERVICE(), isInterceptor, initialOwner, data);
         registerInterface(type(IService).interfaceId);
     }
-
-    // this is just a conveniene function, actual validation will be done upon registration
-    function _getRegistryNftId(address registryAddress) internal view returns (NftId) {
-        return IRegistry(registryAddress).getNftId(registryAddress);
-    }
 }

package/contracts/shared/TokenHandler.sol

@@ -4,6 +4,8 @@ pragma solidity ^0.8.20;
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+/// @dev token specific transfer helper
+/// relies internally on oz SafeERC20.safeTransferFrom
 contract TokenHandler {
     IERC20Metadata private _token;
 
@@ -11,17 +13,21 @@ contract TokenHandler {
         _token = IERC20Metadata(token);
     }
 
-    // TODO add logging
     function transfer(
         address from,
         address to,
-        uint256 amount // TODO add authz (only treasury/instance/product/pool/ service)
-    ) external {
+        uint256 amount
+    )
+        external
+    {
         SafeERC20.safeTransferFrom(_token, from, to, amount);
-        // _token.transferFrom(from, to, amount);
     }
 
-    function getToken() external view returns (IERC20Metadata) {
+    function getToken()
+        external
+        view 
+        returns (IERC20Metadata)
+    {
         return _token;
     }
 }