feat: implements resolve (#11)

Closes EFI-430, EFI-439

Author: 0xItadaki

src/contracts/L2Resolver.sol

@@ -102,6 +102,23 @@ contract L2Resolver is IL2Resolver, IERC165 {
     _chainId = this.getRecord(_node, CHAIN_IDENTIFIER_EIP7930_KEY);
   }
 
+  /// @inheritdoc IL2Resolver
+  function resolve(bytes calldata, bytes calldata _data) external view returns (bytes memory _result) {
+    bytes4 _selector = bytes4(_data);
+
+    if (_selector == this.chainId.selector) {
+      (, bytes32 _node) = abi.decode(_data, (bytes4, bytes32));
+      return abi.encode(this.chainId(_node));
+    }
+
+    if (_selector == this.chainName.selector) {
+      (, bytes memory _chainIdBytes) = abi.decode(_data, (bytes4, bytes));
+      return abi.encode(this.chainName(_chainIdBytes));
+    }
+
+    revert UnsupportedFunctionSelector();
+  }
+
   /// @inheritdoc IERC165
   function supportsInterface(bytes4 _interfaceId) public view virtual override returns (bool _isSupported) {
     _isSupported = _interfaceId == type(IERC165).interfaceId || _interfaceId == type(IExtendedResolver).interfaceId;

src/interfaces/IL2Resolver.sol

@@ -35,6 +35,11 @@ interface IL2Resolver {
    */
   error AddressCannotBeZero();
 
+  /**
+   * @notice Thrown when calling resolve with an unsupported function selector.
+   */
+  error UnsupportedFunctionSelector();
+
   /*///////////////////////////////////////////////////////////////
                             LOGIC
   //////////////////////////////////////////////////////////////*/
@@ -71,6 +76,22 @@ interface IL2Resolver {
    */
   function chainName(bytes calldata _chainIdBytes) external view returns (string memory _chainName);
 
+  /**
+   * @notice Implements the ENSIP-10 Extended Resolver interface.
+   * @notice Routes calls to other specific view functions on this resolver based on the function selector
+   * found in the data parameter.
+   * @param _name DNS-encoded full version of the name being resolved (e.g., dnsencode("optimism.l2.eth")).
+   * @param _data Contains the ABI-encoded function selector and arguments for the actual data being requested.
+   * @dev Currently supports routing to:
+   * - this.chainId(node): If data contains the selector and ABI-encoded arguments for chainId(bytes32).
+   * The node argument is decoded by the resolver from the data parameter.
+   * - this.chainName(chainIdentifierBytes): If data contains the selector and ABI-encoded arguments for
+   * chainName(bytes). The chainIdentifierBytes argument is decoded by the resolver from the data parameter.
+   * @return _result Returns the ABI-encoded result of the target function, or reverts if the data does not
+   * correspond to a supported function or if resolution fails.
+   */
+  function resolve(bytes calldata _name, bytes calldata _data) external view returns (bytes memory _result);
+
   /*///////////////////////////////////////////////////////////////
                             VARIABLES
   //////////////////////////////////////////////////////////////*/

test/unit/L2Resolver.t.sol

@@ -13,18 +13,19 @@ import {IL2Resolver} from 'src/interfaces/IL2Resolver.sol';
 import {INameWrapper} from 'src/interfaces/INameWrapper.sol';
 
 contract UnitL2Resolver is Test {
+  string internal constant _ENS_DOMAIN = 'optimism.l2.eth';
   L2Resolver internal _l2Resolver;
   address internal _ensRegistry = makeAddr('ENSRegistry');
   address internal _nameWrapper = makeAddr('NameWrapper');
   address internal _reverseAdmin = makeAddr('ReverseAdmin');
   address internal _nodeOwner = makeAddr('NodeOwner');
   bytes32 internal _parentNodeNameHash = keccak256('l2.eth');
   bytes32 internal _reverseLookupNode;
-  bytes32 internal _nodeNameHash = keccak256('optimism.l2.eth');
+  bytes32 internal _nodeNameHash = keccak256(abi.encode(_ENS_DOMAIN));
   string internal _key;
   bytes internal _chainIdBytes = hex'00010001010A00';
   string internal _reverseLookupKey;
-  bytes internal _reverseLookupValue = abi.encode('optimism.l2.eth');
+  bytes internal _reverseLookupValue = abi.encode(_ENS_DOMAIN);
 
   function setUp() external {
     _l2Resolver = new L2Resolver(_ensRegistry, _nameWrapper, _reverseAdmin, _parentNodeNameHash);
@@ -394,6 +395,7 @@ contract UnitL2Resolver is Test {
     bytes memory _domainChainIdBytes
   ) external {
     vm.assume(bytes(_ensDomain).length > 0);
+
     bytes memory _value = abi.encode(_ensDomain);
     string memory _reverseKey = string.concat(_key, _bytes32ToHexString(keccak256(_domainChainIdBytes)));
 
@@ -409,6 +411,30 @@ contract UnitL2Resolver is Test {
     assertEq(_l2Resolver.chainName(_chainIdBytes), '');
   }
 
+  function test_ResolveWhenResolvingChainId(bytes calldata _name) external {
+    _setRecord(_nodeNameHash, _key, _chainIdBytes);
+
+    // it returns abi-encoded chain identifier
+    bytes memory _data = abi.encode(IL2Resolver.chainId.selector, _nodeNameHash);
+    assertEq(_l2Resolver.resolve(_name, _data), abi.encode(_chainIdBytes));
+  }
+
+  function test_ResolveWhenResolvingChainName(bytes calldata _name) external {
+    vm.prank(_reverseAdmin);
+    _l2Resolver.setRecord(_reverseLookupNode, _reverseLookupKey, abi.encode(_ENS_DOMAIN));
+
+    // it returns abi-encoded ENS name
+    bytes memory _data = abi.encode(IL2Resolver.chainName.selector, _chainIdBytes);
+    assertEq(_l2Resolver.resolve(_name, _data), abi.encode(_ENS_DOMAIN));
+  }
+
+  function test_ResolveWhenResolvingAnUnsupportedFunction(bytes calldata _name) external {
+    // it reverts
+    bytes memory _data = abi.encode(IL2Resolver.getRecord.selector, _nodeNameHash, _key);
+    vm.expectRevert(abi.encodeWithSelector(IL2Resolver.UnsupportedFunctionSelector.selector));
+    _l2Resolver.resolve(_name, _data);
+  }
+
   /**
    * @notice Sets up a mock and expects a call to it
    *

test/unit/L2Resolver.tree

@@ -73,3 +73,11 @@ UnitL2Resolver::chainName
 │   └── it returns the primary ENS name
 └── when the reverse mapping does not exist
     └── it returns an empty string
+
+UnitL2Resolver::resolve
+├── when resolving chainId
+│   └── it returns abi-encoded chain identifier
+├── when resolving chainName
+│   └── it returns abi-encoded ENS name
+└── when resolving an unsupported function
+    └── it reverts