@etherisc/gif-next 0.0.2-9dd41ff-671 → 0.0.2-9e03baf-990

package/contracts/shared/Component.sol

@@ -6,29 +6,20 @@ import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessMana
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
+import {Amount, AmountLib} from "../type/Amount.sol";
 import {IComponent} from "./IComponent.sol";
 import {IComponents} from "../instance/module/IComponents.sol";
-import {IInstanceService} from "../instance/IInstanceService.sol";
-import {IInstance} from "../instance/IInstance.sol";
-import {InstanceAdmin} from "../instance/InstanceAdmin.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
-import {NftId} from "../type/NftId.sol";
-import {ObjectType, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
+import {IComponentService} from "./IComponentService.sol";
+import {NftId, NftIdLib} from "../type/NftId.sol";
+import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
-import {RoleId, RoleIdLib} from "../type/RoleId.sol";
-import {IAccess} from "../instance/module/IAccess.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {VersionPart} from "../type/Version.sol";
+import {VersionPartLib} from "../type/Version.sol";
 
-// TODO discuss to inherit from oz accessmanaged
-// then add (Distribution|Pool|Product)Upradeable that also intherit from Versionable
-// same pattern as for Service which is also upgradeable
 abstract contract Component is
+    AccessManagedUpgradeable,
     Registerable,
-    IComponent,
-    AccessManagedUpgradeable
+    IComponent
 {
     // keccak256(abi.encode(uint256(keccak256("gif-next.contracts.component.Component.sol")) - 1)) & ~bytes32(uint256(0xff));
     bytes32 public constant COMPONENT_LOCATION_V1 = 0xffe8d4462baed26a47154f4b8f6db497d2f772496965791d25bd456e342b7f00;
@@ -36,18 +27,11 @@ abstract contract Component is
     struct ComponentStorage {
         string _name; // unique (per instance) component name
         IERC20Metadata _token; // token for this component
-        IInstance _instance; // instance for this component
-        address _wallet; // wallet for this component (default = component contract itself)
-        InstanceReader _instanceReader; // instance reader for this component
-        bool _isNftInterceptor; // declares if component is involved in nft transfers
-        NftId _productNftId; // only relevant for components that are linked to a aproduct
+        bool _isInterceptor;
+        bytes _data;
+        IComponentService _componentService;
     }
 
-    function _getComponentStorage() private pure returns (ComponentStorage storage $) {
-        assembly {
-            $.slot := COMPONENT_LOCATION_V1
-        }
-    }
 
     modifier onlyChainNft() {
         if(msg.sender != getRegistry().getChainNftAddress()) {
@@ -56,216 +40,190 @@ abstract contract Component is
         _;
     }
 
-    function initializeComponent(
+    function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        assembly {
+            $.slot := COMPONENT_LOCATION_V1
+        }
+    }
+
+    function _initializeComponent(
+        address authority,
         address registry,
-        NftId instanceNftId,
+        NftId parentNftId,
         string memory name,
         address token,
         ObjectType componentType,
         bool isInterceptor,
         address initialOwner,
-        bytes memory registryData // writeonly data that will saved in the object info record of the registry
+        bytes memory registryData, // writeonly data that will saved in the object info record of the registry
+        bytes memory componentData // other component specific data
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(registry, instanceNftId, componentType, isInterceptor, initialOwner, registryData);
-
-        // set and check linked instance
-        ComponentStorage storage $ = _getComponentStorage();
-        $._instance = IInstance(
-            getRegistry().getObjectInfo(instanceNftId).objectAddress);
+        if (token == address(0)) {
+            revert ErrorComponentTokenAddressZero();
+        }
 
-        if(!$._instance.supportsInterface(type(IInstance).interfaceId)) {
-            revert ErrorComponentNotInstance(instanceNftId);
+        if (bytes(name).length == 0) {
+            revert ErrorComponentNameLengthZero();
         }
 
-        // initialize AccessManagedUpgradeable
-        __AccessManaged_init($._instance.authority());
+        _initializeRegisterable(
+            registry, 
+            parentNftId, 
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData);
+
+        __AccessManaged_init(authority);
 
         // set component state
+        ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
-        $._isNftInterceptor = isInterceptor;
-        $._instanceReader = $._instance.getInstanceReader();
-        $._wallet = address(this);
         $._token = IERC20Metadata(token);
+        $._isInterceptor = isInterceptor;
+        $._data = componentData;
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IComponent).interfaceId);
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IComponent).interfaceId);
     }
 
-    function lock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(true);
-    }
-    
-    function unlock() external onlyOwner {
-        IInstanceService(_getServiceAddress(INSTANCE())).setComponentLocked(false);
-    }
-
-    function approveTokenHandler(uint256 spendingLimitAmount) external onlyOwner {
-        IComponents.ComponentInfo memory info = getComponentInfo();
-
-        if(info.wallet != address(this)) {
-            revert ErrorComponentWalletNotComponent();
-        }
-
-        info.token.approve(
-            address(info.tokenHandler),
-            spendingLimitAmount);
 
-        emit LogComponentTokenHandlerApproved(spendingLimitAmount);
-    }
-
-    function setWallet(address newWallet)
-        external
-        override
-        onlyOwner
+    function approveTokenHandler(IERC20Metadata token, Amount amount)
+        public
+        onlyOwner()
     {
-        ComponentStorage storage $ = _getComponentStorage();
-
-        address currentWallet = $._wallet;
-        uint256 currentBalance = $._token.balanceOf(currentWallet);
-
-        // checks
-        if (newWallet == address(0)) {
-            revert ErrorComponentWalletAddressZero();
-        }
-
-        if (newWallet == currentWallet) {
-            revert ErrorComponentWalletAddressIsSameAsCurrent();
-        }
-
-        if (currentBalance > 0) {
-            if (currentWallet == address(this)) {
-                // move tokens from component smart contract to external wallet
-            } else {
-                // move tokens from external wallet to component smart contract or another external wallet
-                uint256 allowance = $._token.allowance(currentWallet, address(this));
-                if (allowance < currentBalance) {
-                    revert ErrorComponentWalletAllowanceTooSmall(currentWallet, newWallet, allowance, currentBalance);
-                }
-            }
-        }
-
-        // effects
-        $._wallet = newWallet;
-        emit LogComponentWalletAddressChanged(currentWallet, newWallet);
-
-        // interactions
-        if (currentBalance > 0) {
-            // transfer tokens from current wallet to new wallet
-            if (currentWallet == address(this)) {
-                // transferFrom requires self allowance too
-                $._token.approve(address(this), currentBalance);
-            }
-            
-            SafeERC20.safeTransferFrom($._token, currentWallet, newWallet, currentBalance);
-            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
-        }
+        _approveTokenHandler(token, amount);
     }
 
-    function setProductNftId(NftId productNftId)
-        external
-        override
-    {
-        ComponentStorage storage $ = _getComponentStorage();
 
-        // verify caller is product service
-        if(msg.sender != _getServiceAddress(PRODUCT())) {
-            revert ErrorComponentNotProductService(msg.sender);
-        }
+    // TODO cleanup
+    // /// @dev Approves the component's token hander to spend tokens up to the specified limit.
+    // /// When the spending limit amount equals AmountLib.max it is set to type(uint256).max.
+    // function approveTokenHandler(address token, Amount spendingLimitAmount)
+    //     public
+    //     virtual
+    //     onlyOwner
+    // {
+    //     _approveTokenHandler(token, spendingLimitAmount);
+    // }
 
-        // verify component is not yet linked to a product
-        if($._productNftId.gtz()) {
-            revert ErrorComponentProductNftAlreadySet();
-        }
-
-        $._productNftId = productNftId;
-    }
 
-    function nftMint(address to, uint256 tokenId) 
-        external 
-        virtual
-        onlyChainNft
-    {}
+    // function setWallet(address newWallet)
+    //     external
+    //     virtual
+    //     override
+    //     onlyOwner
+    // {
+    //     _setWallet(newWallet);
+    // }
 
     /// @dev callback function for nft transfers
     /// may only be called by chain nft contract.
-    /// do not override this function to implement business logic for handling transfers
-    /// override internal function _nftTransferFrom instead
-    function nftTransferFrom(address from, address to, uint256 tokenId)
+    /// override internal function _nftTransferFrom to implement custom behaviour
+    function nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         external
-        virtual
         onlyChainNft
     {
-        _nftTransferFrom(from, to, tokenId);
+        _nftTransferFrom(from, to, tokenId, operator);
     }
 
-    function getWallet() public view override returns (address walletAddress)
-    {
-        return _getComponentStorage()._wallet;
-    }
 
-    function getToken() public view override returns (IERC20Metadata token) {
-        return _getComponentStorage()._token;
+    function getWallet() public view virtual returns (address walletAddress) {
+        return getTokenHandler().getWallet();
     }
 
-    function getTokenHandler() public view returns (TokenHandler tokenHandler) {
+    function getTokenHandler() public virtual view returns (TokenHandler tokenHandler) {
         return getComponentInfo().tokenHandler;
     }
 
-    function isNftInterceptor() public view override returns(bool isInterceptor) {
-        return _getComponentStorage()._isNftInterceptor;
+    function getToken() public view virtual returns (IERC20Metadata token) {
+        return getComponentInfo().token;
     }
 
-    function getInstance() public view override returns (IInstance instance) {
-        return _getComponentStorage()._instance;
+    function getName() public view override returns(string memory name) {
+        return getComponentInfo().name;
     }
 
-    function getName() public view override returns(string memory name) {
-        return _getComponentStorage()._name;
+    function getComponentInfo() public virtual view returns (IComponents.ComponentInfo memory info) {
+        if (isRegistered()) {
+            return _getComponentInfo();
+        } else {
+            return getInitialComponentInfo();
+        }
     }
 
-    function getProductNftId() public view override returns (NftId productNftId) {
-        return _getComponentStorage()._productNftId;
+    /// @dev defines initial component specification
+    /// overwrite this function according to your use case
+    function getInitialComponentInfo() public virtual view returns (IComponents.ComponentInfo memory info) {
+        return _getComponentInfo();
     }
 
-    function getComponentInfo() public view returns (IComponents.ComponentInfo memory info) {
-        info = _getInstanceReader().getComponentInfo(getNftId());
 
-        // fallback to initial info (wallet is always != address(0))
-        if(info.wallet == address(0)) {
-            info = _getInitialInfo();
+    function isNftInterceptor() public virtual view returns(bool isInterceptor) {
+        if (isRegistered()) {
+            return getRegistry().getObjectInfo(address(this)).isInterceptor;
+        } else {
+            return _getComponentStorage()._isInterceptor;
         }
     }
 
-    /// @dev defines initial component specification
-    /// overwrite this function according to your use case
-    function _getInitialInfo()
+
+    function isRegistered() public virtual view returns (bool) {
+        return getRegistry().getNftIdForAddress(address(this)).gtz();
+    }
+
+
+    function _approveTokenHandler(IERC20Metadata token, Amount amount)
         internal
-        view 
         virtual
-        returns (IComponents.ComponentInfo memory info)
-    { }
+    {
+        _getComponentStorage()._componentService.approveTokenHandler(
+            token, 
+            amount);
+    }
 
 
     /// @dev internal function for nft transfers.
     /// handling logic that deals with nft transfers need to overwrite this function
-    function _nftTransferFrom(address from, address to, uint256 tokenId)
+    function _nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         internal
         virtual
     { }
 
-    /// @dev returns reader for linked instance
-    function _getInstanceReader() internal view returns (InstanceReader reader) {
-        return _getComponentStorage()._instanceReader;
+
+    /// @dev depending on the source of the component information this function needs to be overwritten. 
+    /// eg for instance linked components that externally store this information with the instance store contract
+    function _setWallet(
+        address newWallet
+    )
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setWallet(newWallet);
+    }
+
+
+    /// @dev depending on the source of the component information this function needs to be overwritten. 
+    /// eg for instance linked components that externally store this information with the instance store contract
+    function _getComponentInfo() internal virtual view returns (IComponents.ComponentInfo memory info) {
+        ComponentStorage storage $ = _getComponentStorage();
+        
+        return IComponents.ComponentInfo({
+            name: $._name,
+            token: $._token,
+            tokenHandler: TokenHandler(address(0)),
+            data: $._data // user specific component data
+        });
     }
 
     /// @dev returns the service address for the specified domain
     /// gets address via lookup from registry using the major version form the linked instance
-    function _getServiceAddress(ObjectType domain) internal view returns (address service) {
-        VersionPart majorVersion = _getComponentStorage()._instance.getMajorVersion();
-        return getRegistry().getServiceAddress(domain, majorVersion);
+    function _getServiceAddress(ObjectType domain) internal view returns (address) {
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
 }