Refactoring for resolve() and resolver() ENS methods

- Make ``ENS.resolve()`` an internal method to provide a better user experience / less confusion. ``ENS.address()`` and ``ENS.name()`` should better abstract forward and backward resolution without the need to expose the ``resolve()`` method as part of the API.

- Normalize the name being passed into ``ENS.resolver()`` since this is an exposed method for user input. This is done on other methods for the class but was not yet done for ``ENS.resolver()``.

Author: fselmo

ens/main.py

@@ -152,7 +152,7 @@ def address(self, name: str) -> Optional[ChecksumAddress]:
         :param str name: an ENS name to look up
         :raises InvalidName: if `name` has invalid syntax
         """
-        return cast(ChecksumAddress, self.resolve(name, 'addr'))
+        return cast(ChecksumAddress, self._resolve(name, 'addr'))
 
     def name(self, address: ChecksumAddress) -> Optional[str]:
         """
@@ -163,7 +163,7 @@ def name(self, address: ChecksumAddress) -> Optional[str]:
         :type address: hex-string
         """
         reversed_domain = address_to_reverse_domain(address)
-        name = self.resolve(reversed_domain, fn_name='name')
+        name = self._resolve(reversed_domain, fn_name='name')
 
         # To be absolutely certain of the name, via reverse resolution, the address must match in
         # the forward resolution
@@ -285,38 +285,14 @@ def setup_name(
                 self.setup_address(name, address, transact=transact)
             return self._setup_reverse(name, address, transact=transact)
 
-    def resolver(self, normal_name: str) -> Optional['Contract']:
-        return self._get_resolver(normal_name)[0]
+    def resolver(self, name: str) -> Optional['Contract']:
+        """
+        Get the resolver for an ENS name.
 
-    def resolve(self, name: str, fn_name: str = 'addr') -> Optional[Union[ChecksumAddress, str]]:
+        :param str name: The ENS name
+        """
         normal_name = normalize_name(name)
-
-        resolver, current_name = self._get_resolver(normal_name, fn_name)
-        if not resolver:
-            return None
-
-        node = self.namehash(normal_name)
-
-        if _resolver_supports_interface(resolver, EXTENDED_RESOLVER_INTERFACE_ID):
-            # update the resolver abi to the extended resolver abi
-            extended_resolver = self.w3.eth.contract(abi=abis.EXTENDED_RESOLVER)(resolver.address)
-            contract_func_with_args = (fn_name, [node])
-
-            calldata = extended_resolver.encodeABI(*contract_func_with_args)
-            contract_call_result = extended_resolver.caller.resolve(
-                ens_encode_name(normal_name), calldata
-            )
-            result = self._decode_ensip10_resolve_data(
-                contract_call_result, extended_resolver, fn_name
-            )
-            return to_checksum_address(result) if is_address(result) else result
-        elif normal_name == current_name:
-            lookup_function = getattr(resolver.functions, fn_name)
-            result = lookup_function(node).call()
-            if is_none_or_zero_address(result):
-                return None
-            return to_checksum_address(result) if is_address(result) else result
-        return None
+        return self._get_resolver(normal_name)[0]
 
     def reverser(self, target_address: ChecksumAddress) -> Optional['Contract']:
         reversed_domain = address_to_reverse_domain(target_address)
@@ -456,6 +432,36 @@ def setup_owner(
             self._claim_ownership(new_owner, unowned, owned, super_owner, transact=transact)
             return new_owner
 
+    def _resolve(self, name: str, fn_name: str = 'addr') -> Optional[Union[ChecksumAddress, str]]:
+        normal_name = normalize_name(name)
+
+        resolver, current_name = self._get_resolver(normal_name, fn_name)
+        if not resolver:
+            return None
+
+        node = self.namehash(normal_name)
+
+        if _resolver_supports_interface(resolver, EXTENDED_RESOLVER_INTERFACE_ID):
+            # update the resolver abi to the extended resolver abi
+            extended_resolver = self.w3.eth.contract(abi=abis.EXTENDED_RESOLVER)(resolver.address)
+            contract_func_with_args = (fn_name, [node])
+
+            calldata = extended_resolver.encodeABI(*contract_func_with_args)
+            contract_call_result = extended_resolver.caller.resolve(
+                ens_encode_name(normal_name), calldata
+            )
+            result = self._decode_ensip10_resolve_data(
+                contract_call_result, extended_resolver, fn_name
+            )
+            return to_checksum_address(result) if is_address(result) else result
+        elif normal_name == current_name:
+            lookup_function = getattr(resolver.functions, fn_name)
+            result = lookup_function(node).call()
+            if is_none_or_zero_address(result):
+                return None
+            return to_checksum_address(result) if is_address(result) else result
+        return None
+
     def _assert_control(self, account: ChecksumAddress, name: str,
                         parent_owned: Optional[str] = None) -> None:
         if not address_in(account, self.w3.eth.accounts):

tests/ens/test_resolve.py renamed to tests/ens/test_wildcard_resolution.py

@@ -1,28 +1,18 @@
 import pytest
 
 
-def test_resolve(ens):
-    acct = ens.w3.eth.accounts[2]
-    ens.setup_address('tester.eth', acct)
-
-    assert ens.resolve('tester.eth') == acct
-
-    # clean up
-    ens.setup_address('tester.eth', None)
-
-
 @pytest.mark.parametrize('subdomain', ('sub1', 'sub2', 'rändöm', '🌈rainbow', 'faß'))
 def test_wildcard_resolution_with_extended_resolver_for_subdomains(ens, subdomain):
     # validate subdomains of `extended-resolver.eth` by asserting it returns the specified
     # hard-coded address from `tests/test_contracts/ExtendedResolver.sol` which requires
     # certain conditions to be met that are specific to subdomains only
-    resolved_child_address = ens.resolve(f'{subdomain}.extended-resolver.eth')
+    resolved_child_address = ens.address(f'{subdomain}.extended-resolver.eth')
     assert resolved_child_address == '0x000000000000000000000000000000000000dEaD'
 
 
 def test_wildcard_resolution_with_extended_resolver_for_parent_ens_domain(ens):
     # validate `extended-resolver.eth` by asserting it returns the specified hard-coded address from
     # `tests/test_contracts/ExtendedResolver.sol` which requires a specific condition to be
     # met for the parent domain `extended-resolver.eth`
-    resolved_parent_address = ens.resolve('extended-resolver.eth')
+    resolved_parent_address = ens.address('extended-resolver.eth')
     assert resolved_parent_address == '0x000000000000000000000000000000000000bEEF'