@etherisc/gif-next 0.0.2-e769e2e-077 → 0.0.2-e79d227-681

package/contracts/registry/TokenRegistry.sol

@@ -1,22 +1,34 @@
 // SPDX-License-Identifier: Apache-2.0
 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 {VersionPart} from "../type/Version.sol";
-import {REGISTRY} from "../type/ObjectType.sol";
-import {NftOwnable} from "../shared/NftOwnable.sol";
+import {IRegistryLinked} from "../shared/IRegistryLinked.sol";
+import {ReleaseRegistry} from "./ReleaseRegistry.sol";
+import {RegistryAdmin} from "./RegistryAdmin.sol";
+
 
 /// @title contract to register token per GIF major release.
 contract TokenRegistry is
-    NftOwnable
+    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);
 
+    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);
@@ -29,79 +41,115 @@ contract TokenRegistry is
         address token;
         uint8 decimals;
         string symbol;
+        bool active;
     }
 
-    TokenInfo [] internal _token;
-    mapping(uint256 chainId => mapping(address token => bool registered)) internal _registered;
+    mapping(uint256 chainId => mapping(address token => TokenInfo info)) internal _tokenInfo;
     mapping(uint256 chainId => mapping(address token => mapping(VersionPart majorVersion => bool isActive))) internal _active;
+    TokenInfo [] internal _token;
 
-    constructor(
-        address registry
-    )
-    { 
-        initialize(registry);
+    IRegistry internal _registry;
+    ReleaseRegistry internal _releaseRegistry;
+    IERC20Metadata internal _dipToken;
+
+    /// @dev enforces msg.sender is owner of nft (or initial owner of nft ownable)
+    modifier onlyRegisteredToken(uint256 chainId, address token) {
+        if (!isRegistered(chainId, token)) {
+            revert ErrorTokenRegistryTokenNotRegistered(chainId, token);
+        }
+        _;
     }
 
-    function initialize(address registry)
-        public
-        initializer()
+    constructor(IRegistry registry, IERC20Metadata dipToken)
+        AccessManaged(msg.sender)
     {
-        initializeNftOwnable(msg.sender, registry);
+        // set authority
+        address authority = RegistryAdmin(registry.getRegistryAdminAddress()).authority();
+        setAuthority(authority);
+        
+        _registry = registry;
+        _dipToken = dipToken;
+
+        // register dip token
+        uint256 chainId = block.chainid;
+        _registerToken(
+            chainId, 
+            address(_dipToken), 
+            _dipToken.decimals(), 
+            _dipToken.symbol());
     }
 
 
-    /// @dev link ownership of token registry to nft owner of registry service
-    function linkToRegistryService() 
+    /// @dev register an onchain token.
+    /// this function verifies that the provided token address is a contract that implements
+    /// the non optional erc20 view functions.
+    function registerToken(address tokenAddress)
         external
+        restricted()
     {
-        IRegistry registry = getRegistry();
-        address registryServiceAddress = registry.getServiceAddress(REGISTRY(), registry.getNextVersion());
-
-        _linkToNftOwnable(registryServiceAddress);
+        IERC20Metadata token = _verifyOnchainToken(tokenAddress);
+        _registerToken(block.chainid, tokenAddress, token.decimals(), token.symbol());
     }
 
 
-    function registerToken(address token)
+    /// @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,
+        address token,
+        uint8 decimals,
+        string memory symbol
+    )
         external
-        onlyOwner
+        restricted()
     {
-        uint256 chainId = block.chainid;
-
-        if (_registered[chainId][token]) {
-            revert ErrorTokenRegistryTokenAlreadyRegistered(chainId, token);
+        if (chainId == block.chainid) {
+            revert ErrorTokenRegistryNotRemoteToken(chainId, token);
         }
 
-        // MUST be contract
-        if(token.code.length == 0) {
-            revert ErrorTokenRegistryTokenNotContract(chainId, token);
-        }
+        _registerToken(chainId, token, decimals, symbol);
+    }
 
-        // MUST have decimals > 0 (indicator that this is in fact an erc20 token)
-        IERC20Metadata erc20 = IERC20Metadata(token);
-        if(!_implementsErc20Functions(erc20)) {
-            revert ErrorTokenRegistryTokenNotErc20(chainId, token);
-        }
 
-        _registerToken(chainId, token, erc20.decimals(), erc20.symbol());
+    /// @dev set active flag on token itself.
+    /// when setting a token to active=false isActive will return false
+    /// regardless of release specific active value.
+    function setActive(
+        uint256 chainId, 
+        address token, 
+        bool active
+    )
+        external
+        restricted()
+        onlyRegisteredToken(chainId, token)
+    {
+        _tokenInfo[chainId][token].active = active;
+        emit LogTokenRegistryTokenGlobalStateSet(chainId, token, active);
     }
 
 
-    /// @dev 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 setActive(
+    /// @dev sets active state for specified token and 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, 
         address token, 
         VersionPart majorVersion, 
         bool active
     )
         external
-        onlyOwner
+        restricted()
+        onlyRegisteredToken(chainId, token)
     {
-        setActiveWithVersionCheck(chainId, token, majorVersion, active, true);
+        _setActiveWithVersionCheck(chainId, token, majorVersion, 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.
     function setActiveWithVersionCheck(
         uint256 chainId, 
         address token, 
@@ -109,18 +157,27 @@ contract TokenRegistry is
         bool active,
         bool enforceVersionCheck
     )
-        public
-        onlyOwner
+        external
+        restricted()
+        onlyRegisteredToken(chainId, token)
     {
-        // verify that token is registered
-        if (!_registered[chainId][token]) {
-            revert ErrorTokenRegistryTokenNotRegistered(chainId, token);
-        }
+        _setActiveWithVersionCheck(chainId, token, majorVersion, active, enforceVersionCheck);
+    }
 
+
+    function _setActiveWithVersionCheck(
+        uint256 chainId, 
+        address token, 
+        VersionPart majorVersion, 
+        bool active,
+        bool enforceVersionCheck
+    )
+        internal
+    {
         // verify valid major version
         if(enforceVersionCheck) {
             uint256 version = majorVersion.toInt();
-            if (!getRegistry().isValidRelease(majorVersion)) {
+            if (!getRegistry().isActiveRelease(majorVersion)) {
                 revert ErrorTokenRegistryMajorVersionInvalid(majorVersion);
             }
         }
@@ -130,22 +187,77 @@ contract TokenRegistry is
         emit LogTokenRegistryTokenStateSet(chainId, token, majorVersion, active);
     }
 
+    /// @dev returns the dip token for this chain
+    function getDipToken() external view returns (IERC20Metadata dipToken) {
+        return _dipToken;
+    }
+
+    /// @dev returns the number of registered tokens
     function tokens() external view returns (uint256) {
         return _token.length;
     }
 
-    function getToken(uint256 idx) external view returns (TokenInfo memory tokenInfo) {
+    /// @dev returns the token info for the specified index position [0 .. tokens() - 1].
+    function getTokenInfo(uint256 idx) external view returns (TokenInfo memory tokenInfo) {
         return _token[idx];
     }
 
-    function isRegistered(uint256 chainId, address token) external view returns (bool) {
-        return _registered[chainId][token];
+    /// @dev returns the token info for the specified token coordinates.
+    function getTokenInfo(uint256 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;
     }
 
+    /// @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) {
+        if(!_tokenInfo[chainId][token].active) {
+            return false;
+        }
+
         return _active[chainId][token][majorVersion];
     }
 
+    function getDipTokenAddress() external view returns (address) {
+        return address(_dipToken);
+    }
+
+    //--- IRegistryLinked --------------------------------------------------//
+
+    /// @dev returns the dip token for this chain
+    function getRegistry() public view returns (IRegistry) {
+        return _registry;
+    }
+
+    //--- internal functions ------------------------------------------------//
+
+
+    /// @dev checks if provided token address refers to a smart contract that implements 
+    /// erc20 functionality (via its non-optional functions)
+    function _verifyOnchainToken(address tokenAddress)
+        internal
+        virtual
+        view
+        returns (IERC20Metadata token)
+    {
+        token = IERC20Metadata(tokenAddress);
+        uint256 chainId = block.chainid;
+
+        // MUST be contract
+        if(tokenAddress.code.length == 0) {
+            revert ErrorTokenRegistryTokenNotContract(chainId, tokenAddress);
+        }
+
+        // MUST implement required erc20 view functions
+        if(!_implementsErc20Functions(token)) {
+            revert ErrorTokenRegistryTokenNotErc20(chainId, tokenAddress);
+        }
+    }
+
+
     /// @dev checks availability of non-optional view functions
     /// https://eips.ethereum.org/EIPS/eip-20#methods
     function _implementsErc20Functions(IERC20Metadata token) internal view returns (bool implementsErc20Functions) {
@@ -170,17 +282,33 @@ contract TokenRegistry is
         return true;
     }
 
-    /// @dev some sanity checks to prevent unintended registration
+    /// @dev some sanity checks to prevent unintended registration:
+    /// - token not yet registered
+    /// - chainId not zero
+    /// - token address not zero
     function _registerToken(uint256 chainId, address token, uint8 decimals, string memory symbol) internal {
 
-        _registered[chainId][token] = true;
-        _token.push(
-            TokenInfo({
+        if (isRegistered(chainId, token)) {
+            revert ErrorTokenRegistryTokenAlreadyRegistered(chainId, token);
+        }
+
+        if(chainId == 0) {
+            revert ErrorTokenRegistryChainIdZero();
+        }
+
+        if(token == address(0)) {
+            revert ErrorTokenRegistryTokenAddressZero();
+        }
+
+        TokenInfo memory tokenInfo = TokenInfo({
             chainId: chainId,
             token: token,
             decimals: decimals,
-            symbol: symbol})
-        );
+            symbol: symbol,
+            active: true});
+
+        _tokenInfo[chainId][token] = tokenInfo;
+        _token.push(tokenInfo);
 
         emit LogTokenRegistryTokenRegistered(chainId, token, decimals, symbol);
     }

package/contracts/shared/Component.sol

@@ -6,21 +6,15 @@ 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 {InstanceAccessManager} from "../instance/InstanceAccessManager.sol";
-import {InstanceReader} from "../instance/InstanceReader.sol";
-import {IRegistry} from "../registry/IRegistry.sol";
+import {IComponentService} from "./IComponentService.sol";
 import {NftId, NftIdLib} from "../type/NftId.sol";
-import {ObjectType, INSTANCE, PRODUCT} from "../type/ObjectType.sol";
-import {VersionPart} from "../type/Version.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";
 
 abstract contract Component is
     AccessManagedUpgradeable,
@@ -33,10 +27,9 @@ abstract contract Component is
     struct ComponentStorage {
         string _name; // unique (per instance) component name
         IERC20Metadata _token; // token for this component
-        TokenHandler _tokenHandler;
-        address _wallet;
         bool _isInterceptor;
         bytes _data;
+        IComponentService _componentService;
     }
 
 
@@ -47,14 +40,13 @@ abstract contract Component is
         _;
     }
 
-
     function _getComponentStorage() private pure returns (ComponentStorage storage $) {
         assembly {
             $.slot := COMPONENT_LOCATION_V1
         }
     }
 
-    function initializeComponent(
+    function _initializeComponent(
         address authority,
         address registry,
         NftId parentNftId,
@@ -66,13 +58,10 @@ abstract contract Component is
         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, parentNftId, componentType, isInterceptor, initialOwner, registryData);
-        __AccessManaged_init(authority);
-
         if (token == address(0)) {
             revert ErrorComponentTokenAddressZero();
         }
@@ -81,107 +70,59 @@ abstract contract Component is
             revert ErrorComponentNameLengthZero();
         }
 
+        _initializeRegisterable(
+            registry, 
+            parentNftId, 
+            componentType, 
+            isInterceptor, 
+            initialOwner, 
+            registryData);
+
+        __AccessManaged_init(authority);
+
         // set component state
         ComponentStorage storage $ = _getComponentStorage();
         $._name = name;
         $._token = IERC20Metadata(token);
-        $._tokenHandler = TokenHandler(address(0));
-        $._wallet = address(this);
         $._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 approveTokenHandler(uint256 spendingLimitAmount)
-        external
-        virtual
-        onlyOwner
-    {
-        approveTokenHandler(address(getToken()), spendingLimitAmount);
-    }
-
-    function approveTokenHandler(address token, uint256 spendingLimitAmount)
+    function approveTokenHandler(IERC20Metadata token, Amount amount)
         public
-        virtual
-        onlyOwner
-    {
-        if(getWallet() != address(this)) {
-            revert ErrorComponentWalletNotComponent();
-        }
-
-        IERC20Metadata(token).approve(
-            address(getTokenHandler()),
-            spendingLimitAmount);
-
-        emit LogComponentTokenHandlerApproved(address(getTokenHandler()), spendingLimitAmount);
-    }
-
-    function setWallet(address newWallet)
-        external
-        virtual
-        override
-        onlyOwner
+        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(this));
-                if (allowance < currentBalance) {
-                    revert ErrorComponentWalletAllowanceTooSmall(currentWallet, newWallet, allowance, currentBalance);
-                }
-            }
-        }
-
-        // effects
-        _setWallet(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);
     }
 
 
-    /// @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);
-    }
+    // function setWallet(address newWallet)
+    //     external
+    //     virtual
+    //     override
+    //     onlyOwner
+    // {
+    //     _setWallet(newWallet);
+    // }
 
     /// @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) {
@@ -221,20 +162,23 @@ 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)
+    function _approveTokenHandler(IERC20Metadata token, Amount amount)
         internal
         virtual
-    { }
+    {
+        _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
     { }
@@ -242,45 +186,32 @@ abstract contract Component is
 
     /// @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 {
-        ComponentStorage storage $ = _getComponentStorage();
-        address currentWallet = $._wallet;
-
-        if (newWallet == address(0)) {
-            revert ErrorComponentWalletAddressZero();
-        }
-
-        if (newWallet == currentWallet) {
-            revert ErrorComponentWalletAddressIsSameAsCurrent();
-        }
-
-        $._wallet = newWallet;
-        emit LogComponentWalletAddressChanged(currentWallet, newWallet);
-
-    }
-
-    /// @dev for component contracts that hold its own component information 
-    /// this function creates and sets a token hanlder for the components tokens
-    function _createAndSetTokenHandler()
+    function _setWallet(
+        address newWallet
+    )
         internal
+        virtual
     {
-        ComponentStorage storage $ = _getComponentStorage();
-        $._tokenHandler = new TokenHandler(address($._token));
+        _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,
-            productNftId: NftIdLib.zero(),
             token: $._token,
-            tokenHandler: $._tokenHandler,
-            wallet: $._wallet, // initial wallet address
+            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) {
+        return getRegistry().getServiceAddress(domain, getRelease());
+    }
 }