chore(protocol-contracts): simplify implementation and add supportsInterface support

Author: melanciani

protocol-contracts/confidential-tokens-registry/contracts/ConfidentialTokensRegistry.sol

@@ -3,18 +3,37 @@ pragma solidity ^0.8.27;
 
 import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /**
  * @title ConfidentialTokensRegistry
- * @notice A registry contract to map ERC20 token addresses to their ERC7984 confidential token addresses.
+ * @notice A registry contract to map ERC20 token addresses to their corresponding ERC7984
+ * confidential fhevm wrapper addresses, also called confidential tokens.
  * @dev This contract allows an owner to register new entries and flag revoked ones.
  */
 contract ConfidentialTokensRegistry is Ownable2StepUpgradeable, UUPSUpgradeable {
+    /// @notice Struct to represent a (token, confidential token, is revoked) tuple.
+    struct ConfidentialTokenPair {
+        /// @notice The address of the token.
+        address tokenAddress;
+        /// @notice The address of the confidential token.
+        address confidentialTokenAddress;
+        /// @notice If the confidential token has been revoked.
+        bool isRevoked;
+    }
+
     /// @custom:storage-location erc7201:fhevm_protocol.storage.ConfidentialTokensRegistry
     struct ConfidentialTokensRegistryStorage {
+        /// @notice Mapping from token address to confidential token address.
         mapping(address tokenAddress => address confidentialTokenAddress) _tokensToConfidentialTokens;
+        /// @notice Mapping from confidential token address to token address.
         mapping(address confidentialTokenAddress => address tokenAddress) _confidentialTokensToTokens;
+        /// @notice If a confidential token has been revoked.
         mapping(address confidentialTokenAddress => bool isRevoked) _revokedConfidentialTokens;
+        /// @notice Index of registered tokens.
+        mapping(address tokenAddress => uint256 index) _tokenIndex;
+        /// @notice Registered token and confidential token pairs.
+        ConfidentialTokenPair[] _tokenConfidentialTokenPairs;
     }
 
     // keccak256(abi.encode(uint256(keccak256("fhevm_protocol.storage.ConfidentialTokensRegistry")) - 1)) & ~bytes32(uint256(0xff))
@@ -27,6 +46,13 @@ contract ConfidentialTokensRegistry is Ownable2StepUpgradeable, UUPSUpgradeable
     /// @notice Error thrown when the confidential token address is zero.
     error ConfidentialTokenZeroAddress();
 
+    /// @notice Error thrown when a confidential token is not a valid ERC7984 confidential token
+    /// because it does not support the ERC7984 interface (0x4958f2a4).
+    error NotERC7984(address confidentialTokenAddress);
+
+    /// @notice Error thrown when a confidential token does not support ERC165's `supportsInterface`.
+    error ConfidentialTokenDoesNotSupportERC165(address confidentialTokenAddress);
+
     /// @notice Error thrown when a confidential token is already associated with a token.
     error ConfidentialTokenAlreadyAssociatedWithToken(address tokenAddress, address existingConfidentialTokenAddress);
 
@@ -48,10 +74,6 @@ contract ConfidentialTokensRegistry is Ownable2StepUpgradeable, UUPSUpgradeable
     /// @notice Emitted when a confidential token is revoked and the association with a token is removed.
     event ConfidentialTokenRevoked(address indexed tokenAddress, address indexed confidentialTokenAddress);
 
-    /// @notice Emitted when a confidential token no longer revoked and thus is allowed to be
-    /// associated with a token again.
-    event ConfidentialTokenReinstated(address indexed confidentialTokenAddress);
-
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
@@ -77,28 +99,39 @@ contract ConfidentialTokensRegistry is Ownable2StepUpgradeable, UUPSUpgradeable
             revert ConfidentialTokenZeroAddress();
         }
 
-        // The confidential token must not be revoked.
-        if (isConfidentialTokenRevoked(confidentialTokenAddress)) {
-            revert RevokedConfidentialToken(confidentialTokenAddress);
-        }
+        // The confidential token must support the ERC7984 interface (0x4958f2a4) via
+        // `supportsInterface` from ERC165.
+        // See https://eips.ethereum.org/EIPS/eip-7984.
+        _validateERC7984(confidentialTokenAddress);
 
         // The confidential token must not be already associated with a token.
-        address existingTokenAddress = getTokenAddress(confidentialTokenAddress);
+        (, address existingTokenAddress) = getTokenAddress(confidentialTokenAddress);
         if (existingTokenAddress != address(0)) {
             revert ConfidentialTokenAlreadyAssociatedWithToken(confidentialTokenAddress, existingTokenAddress);
         }
 
         // The token must not be already associated with a confidential token.
-        address existingConfidentialTokenAddress = getConfidentialTokenAddress(tokenAddress);
+        (, address existingConfidentialTokenAddress) = getConfidentialTokenAddress(tokenAddress);
         if (existingConfidentialTokenAddress != address(0)) {
             revert TokenAlreadyAssociatedWithConfidentialToken(tokenAddress, existingConfidentialTokenAddress);
         }
 
         ConfidentialTokensRegistryStorage storage $ = _getConfidentialTokensRegistryStorage();
 
+        // Register the token and confidential token mappings.
         $._tokensToConfidentialTokens[tokenAddress] = confidentialTokenAddress;
         $._confidentialTokensToTokens[confidentialTokenAddress] = tokenAddress;
 
+        // Register the token and confidential token pairs in the array and keep track of their indexes.
+        $._tokenConfidentialTokenPairs.push(
+            ConfidentialTokenPair({
+                tokenAddress: tokenAddress,
+                confidentialTokenAddress: confidentialTokenAddress,
+                isRevoked: false
+            })
+        );
+        $._tokenIndex[tokenAddress] = $._tokenConfidentialTokenPairs.length - 1;
+
         emit ConfidentialTokenRegistered(tokenAddress, confidentialTokenAddress);
     }
 
@@ -117,74 +150,95 @@ contract ConfidentialTokensRegistry is Ownable2StepUpgradeable, UUPSUpgradeable
         }
 
         // The confidential token must be associated with a token.
-        address tokenAddress = getTokenAddress(confidentialTokenAddress);
+        (, address tokenAddress) = getTokenAddress(confidentialTokenAddress);
         if (tokenAddress == address(0)) {
             revert NoTokenAssociatedWithConfidentialToken(confidentialTokenAddress);
         }
 
         ConfidentialTokensRegistryStorage storage $ = _getConfidentialTokensRegistryStorage();
 
-        delete $._confidentialTokensToTokens[confidentialTokenAddress];
-        delete $._tokensToConfidentialTokens[tokenAddress];
         $._revokedConfidentialTokens[confidentialTokenAddress] = true;
 
-        emit ConfidentialTokenRevoked(tokenAddress, confidentialTokenAddress);
-    }
+        // Set token's confidential token address to zero to indicate that it has been revoked.
+        uint256 index = $._tokenIndex[tokenAddress];
+        $._tokenConfidentialTokenPairs[index].isRevoked = true;
 
-    /**
-     * @notice Reinstate an ERC7984 confidential token in case it was revoked. It does not restore
-     * the association with a token, it only allows it to be associated with one again.
-     * @param confidentialTokenAddress The address of the ERC7984 confidential token to reinstate.
-     */
-    function reinstateConfidentialToken(address confidentialTokenAddress) external onlyOwner {
-        ConfidentialTokensRegistryStorage storage $ = _getConfidentialTokensRegistryStorage();
-        if (confidentialTokenAddress == address(0)) {
-            revert ConfidentialTokenZeroAddress();
-        }
-
-        // The confidential token must be revoked.
-        if (!isConfidentialTokenRevoked(confidentialTokenAddress)) {
-            revert ConfidentialTokenNotRevoked(confidentialTokenAddress);
-        }
-
-        $._revokedConfidentialTokens[confidentialTokenAddress] = false;
-        emit ConfidentialTokenReinstated(confidentialTokenAddress);
+        emit ConfidentialTokenRevoked(tokenAddress, confidentialTokenAddress);
     }
-
     /**
      * @notice Returns the address of the confidential token associated with a token. A null address
-     * is returned if no confidential token is associated with the token, meaning it either has
-     * never been registered or it has been revoked.
+     * is returned if no confidential token has been registered for the token.
      * @param tokenAddress The address of the token.
+     * @return True if the confidential token has been revoked, false otherwise.
      * @return The address of the confidential token.
      */
-    function getConfidentialTokenAddress(address tokenAddress) public view returns (address) {
-        return _getConfidentialTokensRegistryStorage()._tokensToConfidentialTokens[tokenAddress];
+    function getConfidentialTokenAddress(address tokenAddress) public view returns (bool, address) {
+        address confidentialTokenAddress = _getConfidentialTokensRegistryStorage()._tokensToConfidentialTokens[
+            tokenAddress
+        ];
+        bool isRevoked = isConfidentialTokenRevoked(confidentialTokenAddress);
+        return (isRevoked, confidentialTokenAddress);
     }
 
     /**
      * @notice Returns the address of the token associated with a confidential token.
-     * A null address is returned if no token is associated with the confidential token, meaning
-     * it either has never been registered or it has been revoked.
+     * A null address is returned if the confidential token has not been registered for any token.
      * @param confidentialTokenAddress The address of the confidential token.
+     * @return True if the confidential token has been revoked, false otherwise.
      * @return The address of the token.
      */
-    function getTokenAddress(address confidentialTokenAddress) public view returns (address) {
-        return _getConfidentialTokensRegistryStorage()._confidentialTokensToTokens[confidentialTokenAddress];
+    function getTokenAddress(address confidentialTokenAddress) public view returns (bool, address) {
+        bool isRevoked = isConfidentialTokenRevoked(confidentialTokenAddress);
+        address tokenAddress = _getConfidentialTokensRegistryStorage()._confidentialTokensToTokens[
+            confidentialTokenAddress
+        ];
+        return (isRevoked, tokenAddress);
+    }
+
+    /**
+     * @notice Returns the array of (token address, confidential token address, is revoked) tuples.
+     * A tuple containing a revoked confidential token is kept in the array and addresses are not
+     * affected, only the isRevoked flag is set to true.
+     * @return The array of (token address, confidential token address, is revoked) tuples.
+     */
+    function getTokenConfidentialTokenPairs() public view returns (ConfidentialTokenPair[] memory) {
+        return _getConfidentialTokensRegistryStorage()._tokenConfidentialTokenPairs;
     }
 
     /**
-     * @notice Returns true if a confidential token is revoked, false otherwise. A revoked
-     * confidential token is not allowed to be associated with a token again.
+     * @notice Returns true if a confidential token has been revoked, false otherwise.
      * @param confidentialTokenAddress The address of the confidential token.
-     * @return True if the confidential token is revoked, false otherwise.
+     * @return True if the confidential token has been revoked, false otherwise.
      */
     function isConfidentialTokenRevoked(address confidentialTokenAddress) public view returns (bool) {
         return _getConfidentialTokensRegistryStorage()._revokedConfidentialTokens[confidentialTokenAddress];
     }
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
+    /**
+     * @notice Validates that a confidential token supports the ERC7984 interface (0x4958f2a4) via
+     * `supportsInterface` from ERC165.
+     * See https://eips.ethereum.org/EIPS/eip-7984.
+     * @param confidentialTokenAddress The address of the confidential token to validate.
+     */
+    function _validateERC7984(address confidentialTokenAddress) internal view {
+        (bool success, bytes memory returnData) = confidentialTokenAddress.staticcall(
+            abi.encodeWithSelector(IERC165.supportsInterface.selector, bytes4(0x4958f2a4))
+        );
+
+        // Check if the address supports the `supportsInterface` function
+        if (!success || returnData.length < 32) {
+            revert ConfidentialTokenDoesNotSupportERC165(confidentialTokenAddress);
+        }
+
+        // Check if the confidential token supports the ERC7984 interface (0x4958f2a4).
+        bool isERC7984InterfaceSupported = abi.decode(returnData, (bool));
+        if (!isERC7984InterfaceSupported) {
+            revert NotERC7984(confidentialTokenAddress);
+        }
+    }
+
     function _getConfidentialTokensRegistryStorage()
         private
         pure

protocol-contracts/confidential-tokens-registry/contracts/mocks/ERC165.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+
+/**
+ * @title ERC165Mock
+ * @notice Minimal mock contract that implements ERC165 interface for testing purposes.
+ */
+contract ERC165Mock is ERC165 {}

protocol-contracts/confidential-tokens-registry/contracts/mocks/ERC7984.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC7984} from "@openzeppelin/confidential-contracts/interfaces/IERC7984.sol";
+
+/**
+ * @title ERC7984Mock
+ * @notice Minimal mock contract that implements ERC7984 interface for testing purposes.
+ */
+contract ERC7984Mock is ERC165 {
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return interfaceId == type(IERC7984).interfaceId || super.supportsInterface(interfaceId);
+    }
+}

protocol-contracts/confidential-tokens-registry/package-lock.json

@@ -23,6 +23,7 @@
     "@nomicfoundation/hardhat-network-helpers": "^1.1.0",
     "@nomicfoundation/hardhat-verify": "^2.1.0",
     "@openzeppelin/hardhat-upgrades": "^3.9.1",
+    "@openzeppelin/confidential-contracts": "^0.3.0",
     "@typechain/ethers-v6": "^0.5.1",
     "@typechain/hardhat": "^9.1.0",
     "@types/chai": "^4.3.20",