@etherisc/gif-next 0.0.2-7bf391b-976 → 0.0.2-7bf6e1c-877

package/contracts/registry/TokenRegistry.sol

@@ -3,57 +3,56 @@ pragma solidity ^0.8.20;
 
 import {AccessManaged} from "@openzeppelin/contracts/access/manager/AccessManaged.sol";
 import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
-import {ERC165Checker} from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
-
-import {REGISTRY} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.sol";
-
-import {IRegisterable} from "../shared/IRegisterable.sol";
 
 import {IRegistry} from "./IRegistry.sol";
 import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
-import {ReleaseRegistry} from "./ReleaseRegistry.sol";
-import {RegistryAdmin} from "./RegistryAdmin.sol";
+import {IStaking} from "../staking/IStaking.sol";
 
+import {ChainId, ChainIdLib} from "../type/ChainId.sol";
+import {RegistryAdmin} from "./RegistryAdmin.sol";
+import {VersionPart} from "../type/Version.sol";
 
-/// @title contract to register token per GIF major release.
+/// @dev The TokenRegistry contract is used to whitelist/manage ERC-20 of tokens per major release.
+/// Only whitelisted tokens can be used as default tokens for products, distribution and pools components.
 contract TokenRegistry is
     AccessManaged,
     IRegistryLinked
 {
-    event LogTokenRegistryTokenRegistered(uint256 chainId, address token, uint256 decimals, string symbol);
-    event LogTokenRegistryTokenGlobalStateSet(uint256 chainId, address token, bool active);
-    event LogTokenRegistryTokenStateSet(uint256 chainId, address token, VersionPart majorVersion, bool active);
+    event LogTokenRegistryTokenRegistered(ChainId chainId, address token, uint256 decimals, string symbol);
+    event LogTokenRegistryTokenGlobalStateSet(ChainId chainId, address token, bool active);
+    event LogTokenRegistryTokenStateSet(ChainId chainId, address token, VersionPart release, bool active);
 
     error ErrorTokenRegistryChainIdZero();
     error ErrorTokenRegistryTokenAddressZero();
 
-    error ErrorTokenRegistryNotRemoteToken(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenAlreadyRegistered(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenNotContract(uint256 chainId, address token);
-    error ErrorTokenRegistryTokenNotErc20(uint256 chainId, address token);
+    error ErrorTokenRegistryNotRemoteToken(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenAlreadyRegistered(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenNotContract(ChainId chainId, address token);
+    error ErrorTokenRegistryTokenNotErc20(ChainId chainId, address token);
 
-    error ErrorTokenRegistryTokenNotRegistered(uint256 chainId, address token);
-    error ErrorTokenRegistryMajorVersionInvalid(VersionPart majorVersion);
+    error ErrorTokenRegistryTokenNotRegistered(ChainId chainId, address token);
+    error ErrorTokenRegistryMajorVersionInvalid(VersionPart release);
 
     struct TokenInfo {
-        uint256 chainId;
-        address token;
-        uint8 decimals;
-        string symbol;
+        // slot 0
+        ChainId chainId; // 96
+        address token; // 20
+        uint8 decimals; // 8
         bool active;
+        // slot 1
+        string symbol;
     }
 
-    mapping(uint256 chainId => mapping(address token => TokenInfo info)) internal _tokenInfo;
-    mapping(uint256 chainId => mapping(address token => mapping(VersionPart majorVersion => bool isActive))) internal _active;
+    mapping(ChainId chainId => mapping(address token => TokenInfo info)) internal _tokenInfo;
+    mapping(ChainId chainId => mapping(address token => mapping(VersionPart release => bool isActive))) internal _active;
     TokenInfo [] internal _token;
 
     IRegistry internal _registry;
-    ReleaseRegistry internal _releaseRegistry;
+    ChainId internal _chainId = ChainIdLib.current();
     IERC20Metadata internal _dipToken;
 
     /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
-    modifier onlyRegisteredToken(uint256 chainId, address token) {
+    modifier onlyRegisteredToken(ChainId chainId, address token) {
         if (!isRegistered(chainId, token)) {
             revert ErrorTokenRegistryTokenNotRegistered(chainId, token);
         }
@@ -68,12 +67,13 @@ contract TokenRegistry is
         setAuthority(authority);
         
         _registry = registry;
-        _dipToken = dipToken;
+
+        // TODO deal with chains without a dip token
+        _dipToken = _verifyOnchainToken(address(dipToken));
 
         // register dip token
-        uint256 chainId = block.chainid;
         _registerToken(
-            chainId, 
+            _chainId, 
             address(_dipToken), 
             _dipToken.decimals(), 
             _dipToken.symbol());
@@ -87,15 +87,18 @@ contract TokenRegistry is
         external
         restricted()
     {
+        // checks
         IERC20Metadata token = _verifyOnchainToken(tokenAddress);
-        _registerToken(block.chainid, tokenAddress, token.decimals(), token.symbol());
+
+        // effects
+        _registerToken(_chainId, tokenAddress, token.decimals(), token.symbol());
     }
 
 
     /// @dev register the remote token with the provided attributes.
     /// this function may not be used for tokens when chainId == block.chainid.
     function registerRemoteToken(
-        uint256 chainId,
+        ChainId chainId,
         address token,
         uint8 decimals,
         string memory symbol
@@ -103,7 +106,7 @@ contract TokenRegistry is
         external
         restricted()
     {
-        if (chainId == block.chainid) {
+        if (chainId == _chainId) {
             revert ErrorTokenRegistryNotRemoteToken(chainId, token);
         }
 
@@ -115,7 +118,7 @@ contract TokenRegistry is
     /// when setting a token to active=false isActive will return false
     /// regardless of release specific active value.
     function setActive(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
         bool active
     )
@@ -128,32 +131,32 @@ contract TokenRegistry is
     }
 
 
-    /// @dev sets active state for specified token and major version.
+    /// @dev sets active state for specified token and release (major version).
     /// internally calls setActiveWithVersionCheck() with enforcing version check.
     /// token state is informative, registry have no clue about used tokens
     /// component owner is responsible for token selection and operations
     /// service MUST deny registration of component with inactive token.
     function setActiveForVersion(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active
     )
         external
         restricted()
         onlyRegisteredToken(chainId, token)
     {
-        _setActiveWithVersionCheck(chainId, token, majorVersion, active, true);
+        _setActiveWithVersionCheck(chainId, token, release, active, true);
     }
 
 
     /// @dev as setActiveForVersion() with the option to skip the version check.
     /// enforcing the version check checks if the provided major version with the release manager. 
-    /// the function reverts if the provided majorVersion is unknown to the release manager.
+    /// the function reverts if the provided release is unknown to the release manager.
     function setActiveWithVersionCheck(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active,
         bool enforceVersionCheck
     )
@@ -161,14 +164,14 @@ contract TokenRegistry is
         restricted()
         onlyRegisteredToken(chainId, token)
     {
-        _setActiveWithVersionCheck(chainId, token, majorVersion, active, enforceVersionCheck);
+        _setActiveWithVersionCheck(chainId, token, release, active, enforceVersionCheck);
     }
 
 
     function _setActiveWithVersionCheck(
-        uint256 chainId, 
+        ChainId chainId, 
         address token, 
-        VersionPart majorVersion, 
+        VersionPart release, 
         bool active,
         bool enforceVersionCheck
     )
@@ -176,15 +179,15 @@ contract TokenRegistry is
     {
         // verify valid major version
         if(enforceVersionCheck) {
-            uint256 version = majorVersion.toInt();
-            if (!getRegistry().isActiveRelease(majorVersion)) {
-                revert ErrorTokenRegistryMajorVersionInvalid(majorVersion);
+            uint256 version = release.toInt();
+            if (!getRegistry().isActiveRelease(release)) {
+                revert ErrorTokenRegistryMajorVersionInvalid(release);
             }
         }
 
-        _active[chainId][token][majorVersion] = active;
+        _active[chainId][token][release] = active;
 
-        emit LogTokenRegistryTokenStateSet(chainId, token, majorVersion, active);
+        emit LogTokenRegistryTokenStateSet(chainId, token, release, active);
     }
 
     /// @dev returns the dip token for this chain
@@ -203,22 +206,22 @@ contract TokenRegistry is
     }
 
     /// @dev returns the token info for the specified token coordinates.
-    function getTokenInfo(uint256 chainId, address token) external view returns (TokenInfo memory tokenInfo) {
+    function getTokenInfo(ChainId chainId, address token) external view returns (TokenInfo memory tokenInfo) {
         return _tokenInfo[chainId][token];
     }
 
     /// @dev returns true iff the specified token has been registered for this TokenRegistry contract.
-    function isRegistered(uint256 chainId, address token) public view returns (bool) {
-        return _tokenInfo[chainId][token].chainId > 0;
+    function isRegistered(ChainId chainId, address token) public view returns (bool) {
+        return _tokenInfo[chainId][token].chainId.gtz();
     }
 
-    /// @dev returns true iff both the token is active for the specfied version and the global token state is active
-    function isActive(uint256 chainId, address token, VersionPart majorVersion) external view returns (bool) {
+    /// @dev returns true iff both the token is active for the specfied release and the global token state is active
+    function isActive(ChainId chainId, address token, VersionPart release) external view returns (bool) {
         if(!_tokenInfo[chainId][token].active) {
             return false;
         }
 
-        return _active[chainId][token][majorVersion];
+        return _active[chainId][token][release];
     }
 
     function getDipTokenAddress() external view returns (address) {
@@ -244,16 +247,15 @@ contract TokenRegistry is
         returns (IERC20Metadata token)
     {
         token = IERC20Metadata(tokenAddress);
-        uint256 chainId = block.chainid;
 
         // MUST be contract
         if(tokenAddress.code.length == 0) {
-            revert ErrorTokenRegistryTokenNotContract(chainId, tokenAddress);
+            revert ErrorTokenRegistryTokenNotContract(ChainIdLib.current(), tokenAddress);
         }
 
         // MUST implement required erc20 view functions
         if(!_implementsErc20Functions(token)) {
-            revert ErrorTokenRegistryTokenNotErc20(chainId, tokenAddress);
+            revert ErrorTokenRegistryTokenNotErc20(ChainIdLib.current(), tokenAddress);
         }
     }
 
@@ -286,13 +288,13 @@ contract TokenRegistry is
     /// - token not yet registered
     /// - chainId not zero
     /// - token address not zero
-    function _registerToken(uint256 chainId, address token, uint8 decimals, string memory symbol) internal {
+    function _registerToken(ChainId chainId, address token, uint8 decimals, string memory symbol) internal {
 
         if (isRegistered(chainId, token)) {
             revert ErrorTokenRegistryTokenAlreadyRegistered(chainId, token);
         }
 
-        if(chainId == 0) {
+        if(chainId.eqz()) {
             revert ErrorTokenRegistryChainIdZero();
         }
 

package/contracts/shared/Component.sol

@@ -1,22 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.20;
 
-import {AccessManagedUpgradeable} from "@openzeppelin/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
 import {IAccessManaged} from "@openzeppelin/contracts/access/manager/IAccessManaged.sol";
 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 {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType} from "../type/ObjectType.sol";
+import {IComponentService} from "./IComponentService.sol";
+import {NftId} from "../type/NftId.sol";
+import {ObjectType, COMPONENT} from "../type/ObjectType.sol";
 import {Registerable} from "../shared/Registerable.sol";
 import {TokenHandler} from "../shared/TokenHandler.sol";
-import {VersionPartLib} from "../type/Version.sol";
+import {Version, VersionLib} from "../type/Version.sol";
+
 
 abstract contract Component is
-    AccessManagedUpgradeable,
     Registerable,
     IComponent
 {
@@ -25,10 +24,8 @@ abstract contract Component is
 
     struct ComponentStorage {
         string _name; // unique (per instance) component name
-        IERC20Metadata _token; // token for this component
-        address _wallet;
         bool _isInterceptor;
-        bytes _data;
+        IComponentService _componentService;
     }
 
 
@@ -39,147 +36,66 @@ abstract contract Component is
         _;
     }
 
-    modifier onlyNftOwner(NftId nftId) {
-        if(msg.sender != getRegistry().ownerOf(nftId)) {
-            revert ErrorNftOwnableNotOwner(msg.sender);
-        }
-        _;
-    }
 
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
         assembly {
             $.slot := COMPONENT_LOCATION_V1
         }
     }
 
-    function initializeComponent(
+
+    function __Component_init(
         address authority,
         address registry,
         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 componentData // other component specific data
+        bytes memory registryData // writeonly data that will saved in the object info record of the registry
     )
-        public
+        internal
         virtual
         onlyInitializing()
     {
-        initializeRegisterable(registry, parentNftId, componentType, isInterceptor, initialOwner, registryData);
-        __AccessManaged_init(authority);
-
-        if (token == address(0)) {
-            revert ErrorComponentTokenAddressZero();
-        }
-
         if (bytes(name).length == 0) {
             revert ErrorComponentNameLengthZero();
         }
 
+        __Registerable_init(
+            authority,
+            registry, 
+            parentNftId, 
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData);
+
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
-        $._token = IERC20Metadata(token);
-        $._wallet = address(this);
         $._isInterceptor = isInterceptor;
-        $._data = componentData;
-
-        registerInterface(type(IAccessManaged).interfaceId);
-        registerInterface(type(IComponent).interfaceId);
-    }
-
-
-    function approveTokenHandler(Amount spendingLimitAmount)
-        external
-        virtual
-        onlyOwner
-    {
-        approveTokenHandler(address(getToken()), spendingLimitAmount);
-    }
-
-    function approveTokenHandler(address token, Amount spendingLimitAmount)
-        public
-        virtual
-        onlyOwner
-    {
-        if(getWallet() != address(this)) {
-            revert ErrorComponentWalletNotComponent();
-        }
-
-        emit LogComponentTokenHandlerApproved(address(getTokenHandler()), spendingLimitAmount);
-
-        IERC20Metadata(token).approve(
-            address(getTokenHandler()),
-            spendingLimitAmount.toInt());
-    }
-
-    function setWallet(address newWallet)
-        external
-        virtual
-        override
-        onlyOwner
-    {
-        // checks
-        address currentWallet = getWallet();
-        IERC20Metadata token = getToken();
-        uint256 currentBalance = token.balanceOf(currentWallet);
-
-        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(getTokenHandler()));
-                if (allowance < currentBalance) {
-                    revert ErrorComponentWalletAllowanceTooSmall(currentWallet, newWallet, allowance, currentBalance);
-                }
-            }
-        }
-
-        // effects
-        _setWallet(newWallet);
-
-        // interactions
-        if (currentBalance > 0) {
-            emit LogComponentWalletTokensTransferred(currentWallet, newWallet, currentBalance);
+        $._componentService = IComponentService(_getServiceAddress(COMPONENT()));
 
-            // transfer tokens from current wallet to new wallet
-            if (currentWallet == address(this)) {
-                // transferFrom requires self allowance too
-                token.approve(address(getTokenHandler()), currentBalance);
-            }
-            
-            getTokenHandler().transfer(currentWallet, newWallet, AmountLib.toAmount(currentBalance));
-        }
+        _registerInterface(type(IAccessManaged).interfaceId);
+        _registerInterface(type(IComponent).interfaceId);
     }
 
 
-    /// @dev callback function for nft mints
-    /// may only be called by chain nft contract.
-    /// override internal function _nftMint to implement custom behaviour
-    function nftMint(address to, uint256 tokenId) 
-        external 
-        onlyChainNft
-    {
-        _nftMint(to, tokenId);
-    }
-
     /// @dev callback function for nft transfers
     /// may only be called by chain nft contract.
     /// override internal function _nftTransferFrom to implement custom behaviour
-    function nftTransferFrom(address from, address to, uint256 tokenId)
+    function nftTransferFrom(address from, address to, uint256 tokenId, address operator)
         external
         onlyChainNft
     {
-        _nftTransferFrom(from, to, tokenId);
+        _nftTransferFrom(from, to, tokenId, operator);
     }
 
 
     function getWallet() public view virtual returns (address walletAddress) {
-        return getComponentInfo().wallet;
+        return getTokenHandler().getWallet();
     }
 
     function getTokenHandler() public virtual view returns (TokenHandler tokenHandler) {
@@ -187,13 +103,17 @@ abstract contract Component is
     }
 
     function getToken() public view virtual returns (IERC20Metadata token) {
-        return getComponentInfo().token;
+        return getTokenHandler().TOKEN();
     }
 
     function getName() public view override returns(string memory name) {
         return getComponentInfo().name;
     }
 
+    function getVersion() public view virtual returns (Version version) {
+        return VersionLib.toVersion(1, 0, 0);
+    }
+
     function getComponentInfo() public virtual view returns (IComponents.ComponentInfo memory info) {
         if (isRegistered()) {
             return _getComponentInfo();
@@ -219,42 +139,55 @@ abstract contract Component is
 
 
     function isRegistered() public virtual view returns (bool) {
-        return getRegistry().getNftId(address(this)).gtz();
+        return getRegistry().getNftIdForAddress(address(this)).gtz();
     }
 
 
-    /// @dev internal function for nft transfers.
-    /// handling logic that deals with nft transfers need to overwrite this function
-    function _nftMint(address to, uint256 tokenId)
+    /// @dev Approves token hanlder to spend up to the specified amount of tokens.
+    /// Reverts if component wallet is not token handler itself.
+    /// Only component owner (nft holder) is authorizes to call this function.
+    function _approveTokenHandler(IERC20Metadata token, Amount amount)
         internal
         virtual
-    { }
+        returns (Amount oldAllowanceAmount)
+    {
+        oldAllowanceAmount = AmountLib.toAmount(
+            token.allowance(address(getTokenHandler()), address(this)));
+
+        _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
-    { }
+    // solhint-disable-next-line no-empty-blocks
+    { 
+        // empty default implementation
+    }
 
 
-    /// @dev depending on the source of the component information this function needs to be overwritten. 
+    /// @dev Sets the components wallet to the specified address.
+    /// 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 {
-        ComponentStorage storage $ = _getComponentStorage();
-        address currentWallet = $._wallet;
-
-        if (newWallet == address(0)) {
-            revert ErrorComponentWalletAddressZero();
-        }
-
-        if (newWallet == currentWallet) {
-            revert ErrorComponentWalletAddressIsSameAsCurrent();
-        }
-
-        $._wallet = newWallet;
-        emit LogComponentWalletAddressChanged(currentWallet, newWallet);
+    function _setWallet(
+        address newWallet
+    )
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setWallet(newWallet);
+    }
 
+    function _setLocked(bool locked)
+        internal
+        virtual
+    {
+        _getComponentStorage()._componentService.setLocked(locked);
     }
 
 
@@ -265,17 +198,13 @@ abstract contract Component is
         
         return IComponents.ComponentInfo({
             name: $._name,
-            productNftId: NftIdLib.zero(),
-            token: $._token,
-            tokenHandler: TokenHandler(address(0)),
-            wallet: $._wallet, // initial wallet address
-            data: $._data // user specific component data
+            tokenHandler: TokenHandler(address(0))
         });
     }
 
-    function _approveTokenHandler(uint256 amount) internal {
-        ComponentStorage storage $ = _getComponentStorage();
-        $._token.approve(address(getComponentInfo().tokenHandler), amount);
+    /// @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) {
+        return getRegistry().getServiceAddress(domain, getRelease());
     }
-
 }