@etherisc/gif-next 0.0.2-d408403-475 → 0.0.2-d63a6a1-078

package/contracts/shared/IVersionable.sol

@@ -1,9 +1,34 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
 
-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() is called from Versionable contructor
+// 7) use namespace storage
+// 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)
+//    otherwise, it is still possible to upgrade contract, but everyone who is using it will have to switch to a new fucntions
+//    in some cases this ok but not in the others...
+//
+// IMPORTANT
+// Each 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 {
 
@@ -15,22 +40,35 @@ 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
+     * @dev returns version of this contract
+     * each new implementation MUST implement this function
+     * version number MUST increase 
      */
     function getVersion() external pure returns(Version);
 
@@ -49,4 +87,10 @@ interface IVersionable {
      */
     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

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {INftOwnable} from "./INftOwnable.sol";
+import {IRegistry} from "../registry/IRegistry.sol";
+import {NftId, zeroNftId} from "../types/NftId.sol";
+
+contract NftOwnable is INftOwnable {
+
+    IRegistry internal _registry;
+    NftId private _nftId;
+    address private _initialOwner; 
+
+    /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
+    modifier onlyOwner() {
+        address owner = getOwner();
+
+        // owner == address(0) is eg uninitialized upgradable contract
+        if (owner != address(0) && msg.sender != owner) {
+            revert ErrorNotOwner(msg.sender);
+        }
+        _;
+    }
+
+    constructor() {
+        _initialOwner = msg.sender;
+    }
+
+    /// @dev links this contract to nft after registration
+    // needs to be done once per registered contract and 
+    // reduces registry calls to check ownership
+    // does not need any protection as function can only do the "right thing"
+    function linkToRegisteredNftId() public {
+        if (_nftId.gtz()) {
+            revert ErrorAlreadyLinked(address(_registry), _nftId);
+        }
+
+        if (address(_registry) == address(0)) {
+            revert ErrorRegistryNotInitialized();
+        }
+
+        address contractAddress = address(this);
+
+        if (!_registry.isRegistered(contractAddress)) {
+            revert ErrorContractNotRegistered(contractAddress);
+        }
+
+        _nftId = _registry.getNftId(contractAddress);
+    }
+
+
+    function getRegistry() public view virtual override returns (IRegistry) {
+        return _registry;
+    }
+
+
+    function getNftId() public view virtual override returns (NftId) {
+        return _nftId;
+    }
+
+
+    function getOwner() public view virtual override returns (address) {
+        if (_nftId.gtz()) {
+            return _registry.ownerOf(_nftId);
+        }
+
+        return _initialOwner;
+    }
+
+
+    /// @dev initialization for upgradable contracts
+    // used in _initializeRegisterable
+    function _initializeNftOwnable(
+        address initialOwner,
+        address registryAddress
+    )
+        internal
+        virtual
+    {
+        _initialOwner = initialOwner;
+        _setRegistry(registryAddress);
+    }
+
+
+    /// @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)
+    {
+        if (_nftId.gtz()) {
+            revert ErrorAlreadyLinked(address(_registry), _nftId);
+        }
+
+        _setRegistry(registryAddress);
+
+        if (!_registry.isRegistered(nftOwnableAddress)) {
+            revert ErrorContractNotRegistered(nftOwnableAddress);
+        }
+
+        _nftId = _registry.getNftId(nftOwnableAddress);
+
+        return _nftId;
+    }
+
+
+    function _setRegistry(address registryAddress)
+        private
+    {
+        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);
+        }
+    }
+}

package/contracts/shared/ProxyManager.sol

@@ -0,0 +1,94 @@
+// 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 {IVersionable} from "./IVersionable.sol";
+import {NftOwnable} from "./NftOwnable.sol";
+import {UpgradableProxyWithAdmin} from "./UpgradableProxyWithAdmin.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);
+
+    error ErrorAlreadyDeployed();
+    error ErrorAlreadyDeployedWithSalt();
+    error ErrorNotYetDeployed();
+
+    UpgradableProxyWithAdmin internal _proxy;
+    bool internal _isDeployed;
+
+    /// @dev only used to capture proxy owner
+    constructor()
+        NftOwnable()
+    { }
+
+    /// @dev deploy initial contract
+    function deploy(address initialImplementation, bytes memory initializationData)
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        if (_isDeployed) { revert ErrorAlreadyDeployed(); }
+
+        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
+        );
+
+        _isDeployed = true;
+        versionable = IVersionable(address(_proxy));
+
+        emit LogProxyDeployed(address(_proxy), initialImplementation);
+    }
+
+    /// @dev upgrade existing contract
+    function upgrade(address newImplementation, bytes memory upgradeData)
+        public
+        virtual
+        onlyOwner()
+        returns (IVersionable versionable)
+    {
+        if (!_isDeployed) { revert ErrorNotYetDeployed(); }
+
+        address currentProxyOwner = getOwner();
+        ProxyAdmin proxyAdmin = getProxy().getProxyAdmin();
+        ITransparentUpgradeableProxy proxy = ITransparentUpgradeableProxy(address(_proxy));
+        bytes memory data = getUpgradeData(newImplementation, currentProxyOwner, upgradeData);
+
+        proxyAdmin.upgradeAndCall(
+            proxy,
+            newImplementation, 
+            data);
+
+        versionable = IVersionable(address(_proxy));
+
+        emit LogProxyUpgraded(address(_proxy), newImplementation);
+
+    }
+
+    function getDeployData(address implementation, address proxyOwner, bytes memory deployData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(IVersionable.initialize.selector, implementation, proxyOwner, deployData);
+    }
+
+    function getUpgradeData(address implementation, address proxyOwner, bytes memory upgradeData) public pure returns (bytes memory data) {
+        return abi.encodeWithSelector(IVersionable.upgrade.selector, implementation, proxyOwner, upgradeData);
+    }
+
+    function getProxy() public returns (UpgradableProxyWithAdmin) {
+        return _proxy;
+    }
+}

package/contracts/shared/Registerable.sol

@@ -1,86 +1,89 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
+pragma solidity ^0.8.20;
+
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; 
 
 import {NftId, zeroNftId} from "../types/NftId.sol";
+import {NftOwnable} from "../shared/NftOwnable.sol";
 import {ObjectType} from "../types/ObjectType.sol";
 
 import {IRegistry} from "../registry/IRegistry.sol";
 import {IRegisterable} from "./IRegisterable.sol";
+import {Versionable} from "./Versionable.sol";
 
 import {ERC165} from "./ERC165.sol";
 
-abstract contract Registerable is
+contract Registerable is
     ERC165,
+    Initializable,
+    NftOwnable,
     IRegisterable
 {
-    IRegistry internal immutable _registry;
-    NftId internal immutable _parentNftId;
-    address internal immutable _initialOwner;
+    // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.shared.Registerable.sol")) - 1)) & ~bytes32(uint256(0xff));
+    bytes32 public constant REGISTERABLE_LOCATION_V1 = 0x6548007c3f4340f82f348c576c0ff69f4f529cadd5ad41f96aae61abceeaa300;
 
-    modifier onlyOwner() virtual {
-        require(
-            msg.sender == getOwner(),
-            "ERROR:RGB-001:NOT_OWNER"
-        );
-        _;
+    error ErrorRegisterableNotRegistry(address registryAddress);
+
+    struct RegisterableStorage {
+        NftId _parentNftId;
+        ObjectType _objectType;
+        bool _isInterceptor;
+        bytes _data;
+    }
+
+    function _getRegisterableStorage() private pure returns (RegisterableStorage storage $) {
+        assembly {
+            $.slot := REGISTERABLE_LOCATION_V1
+        }
     }
 
-    constructor(
+    function _initializeRegisterable(
         address registryAddress,
-        NftId parentNftId
+        NftId parentNftId,
+        ObjectType objectType,
+        bool isInterceptor,
+        address initialOwner,
+        bytes memory data
     )
-        ERC165()
+        internal
+        //onlyInitializing//TODO uncomment when "fully" upgradeable
+        virtual
     {
-        require(
-            address(registryAddress) != address(0),
-            "ERROR:RGB-010:REGISTRY_ZERO"
-        );
-
-        _registry = IRegistry(registryAddress);
-        require(
-            _registry.supportsInterface(type(IRegistry).interfaceId),
-            "ERROR:RGB-011:NOT_REGISTRY"
-        );
+        _initializeNftOwnable(
+            initialOwner,
+            registryAddress);
 
-        _parentNftId = parentNftId;
-        require(
-            _registry.isRegistered(_parentNftId),
-            "ERROR:RGB-012:PARENT_NOT_REGISTERED"
-        );
+        // 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...
 
-        _initialOwner = msg.sender;
+        RegisterableStorage storage $ = _getRegisterableStorage();
+        $._parentNftId = parentNftId;
+        $._objectType = objectType;
+        $._isInterceptor = isInterceptor;
+        $._data = data;
 
-        // register support for IRegisterable
         _registerInterface(type(IRegisterable).interfaceId);
     }
 
-    // from IRegistryLinked
-    function register() public onlyOwner virtual override returns (NftId nftId) {
-        return _registry.register(address(this));
-    }
 
-    function getRegistry() public view virtual override returns (IRegistry registry) {
-        return _registry;
-    }
-
-    function getOwner() public view virtual override returns (address owner) {
-        NftId nftId = _registry.getNftId(address(this));
-        if(nftId == zeroNftId()) {
-            return _initialOwner;
-        }
-
-        return _registry.getOwner(nftId);
-    }
-
-    function getNftId() public view override returns (NftId nftId) {
-        return _registry.getNftId(address(this));
-    }
-
-    function getParentNftId() public view override returns (NftId nftId) {
-        return _parentNftId;
-    }
-
-    function getData() public view virtual override returns (bytes memory data) {
-        return "";
+    function getInitialInfo() 
+        public 
+        view 
+        virtual 
+        returns (IRegistry.ObjectInfo memory, bytes memory data) 
+    {
+        RegisterableStorage storage $ = _getRegisterableStorage();
+        return (
+            IRegistry.ObjectInfo(
+                getNftId(),
+                $._parentNftId,
+                $._objectType,
+                $._isInterceptor,
+                address(this), 
+                getOwner(),
+                $._data
+            ),
+            bytes("")
+        );
     }
-}
+}

package/contracts/shared/RegisterableUpgradable.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {Registerable} from "./Registerable.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev base contract for upgradable objects like services and upgradable components
+/// deriving contracs need to call _initializeRegisterable
+/// TODO internalizes versionable here, a non-registerable versionalbe might itself have some value but is outside the scope of the gif
+/// after this merge versionable will no longer exist on its own in gif
+/// only registerable and upgradable (which is a registerable too) will remain
+abstract contract RegisterableUpgradable is 
+    Registerable,
+    Versionable
+{
+}

package/contracts/shared/Service.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+import {IRegistry} from "../registry/IRegistry.sol";
+import {IService} from "./IService.sol";
+import {IVersionable} from "./IVersionable.sol";
+import {NftId, zeroNftId} from "../types/NftId.sol";
+import {RegisterableUpgradable} from "./RegisterableUpgradable.sol";
+import {SERVICE} from "../types/ObjectType.sol";
+import {Version, VersionPart, VersionLib} from "../types/Version.sol";
+import {Versionable} from "./Versionable.sol";
+
+/// @dev service base contract
+abstract contract Service is 
+    RegisterableUpgradable,
+    IService
+{
+    function getName() public pure virtual override returns(string memory name);
+
+    function getMajorVersion() public view virtual override returns(VersionPart majorVersion) {
+        return getVersion().toMajorPart(); 
+    }
+
+    // from Versionable
+    function getVersion()
+        public 
+        pure 
+        virtual override (IVersionable, Versionable)
+        returns(Version)
+    {
+        return VersionLib.toVersion(3,0,0);
+    }
+
+    function _initializeService(
+        address registry, 
+        address initialOwner
+    )
+        internal
+        //onlyInitializing //TODO uncomment when "fully" upgradeable
+    {
+        // service must provide its name and version upon registration
+        bytes memory data = abi.encode(getName(), getMajorVersion());
+        NftId registryNftId = _getRegistryNftId(registry); 
+        bool isInterceptor = false;
+
+        _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

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+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";
+
+contract TokenHandler {
+    IERC20Metadata private _token;
+
+    constructor(address token) {
+        _token = IERC20Metadata(token);
+    }
+
+    // TODO add logging
+    function transfer(
+        address from,
+        address to,
+        uint256 amount // TODO add authz (only treasury/instance/product/pool/ service)
+    ) external {
+        SafeERC20.safeTransferFrom(_token, from, to, amount);
+        // _token.transferFrom(from, to, amount);
+    }
+
+    function getToken() external view returns (IERC20Metadata) {
+        return _token;
+    }
+}

package/contracts/shared/UpgradableProxyWithAdmin.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import {TransparentUpgradeableProxy, ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+import {IVersionable} from "./IVersionable.sol";
+
+contract UpgradableProxyWithAdmin is TransparentUpgradeableProxy {
+
+    constructor(address implementation, address initialProxyAdminOwner, bytes memory data)
+        TransparentUpgradeableProxy(implementation, initialProxyAdminOwner, data)
+    {}
+
+    function getProxyAdmin() external returns (ProxyAdmin) { return ProxyAdmin(_proxyAdmin()); }
+}