@etherisc/gif-next 0.0.2-e769e2e-077 → 0.0.2-e802d97-477

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 {ReleaseManager} from "./ReleaseManager.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;
+    ReleaseManager internal _releaseManager;
+    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);
     }