Add ENSIP-10 support:

- Adds support for the extended resolver concept as defined by ENSIP-10.
- Adds the method ``parent()`` to the ENS class whose function is to extract the proper parent from an ENS name.
- Adds the ``ens_encode_name()`` method that uses DNS name-encoding standards with a few tweaks, such as skipping the fully-encoded length validation for the domain (limit of 255 for DNS) and encoding the empty names as defined by ENSIP-10 as a single zero byte ``b'\x00'``.
- Adds an abstracted logic for decoding the raw result of a contract method as a ``decodeABI()`` method on the ``Contract`` class to facilitate implementation of ENSIP-10.

Unrelated:

- Minor cleanup for some existing ens tests

Author: fselmo

ens/abis.py

@@ -18,3 +18,9 @@
 REVERSE_REGISTRAR_DOMAIN = 'addr.reverse'
 
 ENS_MAINNET_ADDR = ChecksumAddress(HexAddress(HexStr('0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e')))
+
+
+# --- interface ids --- #
+
+GET_TEXT_INTERFACE_ID = HexStr("0x59d1d43c")
+EXTENDED_RESOLVER_INTERFACE_ID = HexStr('0x9061b923')  # ENSIP-10

ens/constants.py

@@ -40,6 +40,20 @@ class UnownedName(Exception):
     pass
 
 
+class ResolverNotFound(Exception):
+    """
+    Raised if no resolver was found for the name you are trying to resolve.
+    """
+    pass
+
+
+class UnsupportedFunction(Exception):
+    """
+    Raised if a resolver does not support a particular method.
+    """
+    pass
+
+
 class BidTooLow(ValueError):
     """
     Raised if you bid less than the minimum amount

ens/contract_data.py

@@ -17,8 +17,10 @@
     Address,
     ChecksumAddress,
     HexAddress,
+    HexStr,
 )
 from eth_utils import (
+    is_address,
     is_binary_address,
     is_checksum_address,
     to_checksum_address,
@@ -34,18 +36,24 @@
 from ens.constants import (
     EMPTY_ADDR_HEX,
     ENS_MAINNET_ADDR,
+    EXTENDED_RESOLVER_INTERFACE_ID,
+    GET_TEXT_INTERFACE_ID,
     REVERSE_REGISTRAR_DOMAIN,
 )
 from ens.exceptions import (
     AddressMismatch,
+    ResolverNotFound,
     UnauthorizedError,
     UnownedName,
+    UnsupportedFunction,
 )
 from ens.utils import (
     address_in,
     address_to_reverse_domain,
     default,
+    ens_encode_name,
     init_web3,
+    is_empty_name,
     is_none_or_zero_address,
     is_valid_name,
     label_to_hash,
@@ -119,7 +127,8 @@ def __init__(
 
         ens_addr = addr if addr else ENS_MAINNET_ADDR
         self.ens = self.w3.eth.contract(abi=abis.ENS, address=ens_addr)
-        self._resolverContract = self.w3.eth.contract(abi=abis.RESOLVER)
+        self._resolver_contract = self.w3.eth.contract(abi=abis.RESOLVER)
+        self._reverse_resolver_contract = self.w3.eth.contract(abi=abis.REVERSE_RESOLVER)
 
     @classmethod
     def fromWeb3(cls, w3: 'Web3', addr: ChecksumAddress = None) -> 'ENS':
@@ -152,18 +161,40 @@ def name(self, address: ChecksumAddress) -> Optional[str]:
         :type address: hex-string
         """
         reversed_domain = address_to_reverse_domain(address)
-        name = self.resolve(reversed_domain, get='name')
+        name = self.resolve(reversed_domain, func='name')
 
         # To be absolutely certain of the name, via reverse resolution, the address must match in
         # the forward resolution
         return name if to_checksum_address(address) == self.address(name) else None
 
+    @staticmethod
+    def parent(name: str) -> str:
+        """
+        Part of ENSIP-10. Returns the parent of a given ENS name, or the empty string if the ENS
+        name does not have a parent.
+
+        e.g.
+        - parent('1.foo.bar.eth') = 'foo.bar.eth'
+        - parent('foo.bar.eth') = 'bar.eth'
+        - parent('foo.eth') = 'eth'
+        - parent('eth') is defined as the empty string ''
+
+        :param name: an ENS name
+        :return: the parent for the provided ENS name
+        :rtype: str
+        """
+        if not name:
+            return ''
+
+        labels = name.split('.')
+        return '' if len(labels) == 1 else '.'.join(labels[1:])
+
     def setup_address(
         self,
         name: str,
         address: Union[Address, ChecksumAddress, HexAddress] = cast(ChecksumAddress, default),
         transact: Optional["TxParams"] = None
-    ) -> HexBytes:
+    ) -> Optional[HexBytes]:
         """
         Set up the name to point to the supplied address.
         The sender of the transaction must own the name, or
@@ -252,24 +283,38 @@ def setup_name(
                 self.setup_address(name, address, transact=transact)
             return self._setup_reverse(name, address, transact=transact)
 
-    def resolve(self, name: str, get: str = 'addr') -> Optional[Union[ChecksumAddress, str]]:
+    def resolver(self, normal_name: str) -> Optional['Contract']:
+        return self._get_resolver(normal_name)[0]
+
+    def resolve(self, name: str, func: str = 'addr') -> Optional[Union[ChecksumAddress, str]]:
         normal_name = normalize_name(name)
-        resolver = self.resolver(normal_name)
-        if resolver:
-            lookup_function = getattr(resolver.functions, get)
-            namehash = normal_name_to_hash(normal_name)
-            address = lookup_function(namehash).call()
-            if is_none_or_zero_address(address):
-                return None
-            return address
-        else:
-            return None
 
-    def resolver(self, normal_name: str) -> Optional['Contract']:
-        resolver_addr = self.ens.caller.resolver(normal_name_to_hash(normal_name))
-        if is_none_or_zero_address(resolver_addr):
+        resolver, current_name = self._get_resolver(normal_name, func)
+        if not resolver:
             return None
-        return self._resolverContract(address=resolver_addr)
+
+        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 = (func, [node])
+
+            calldata = extended_resolver.encodeABI(*contract_func_with_args)
+            contract_call_result = extended_resolver.caller.resolve(
+                ens_encode_name(normal_name), calldata
+            )
+            decoded_result = extended_resolver.decodeABI(
+                *contract_func_with_args, result=contract_call_result
+            )
+            return decoded_result
+        elif normal_name == current_name:
+            lookup_function = getattr(resolver.functions, func)
+            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 reverser(self, target_address: ChecksumAddress) -> Optional['Contract']:
         reversed_domain = address_to_reverse_domain(target_address)
@@ -295,38 +340,51 @@ def get_text(self, name: str, key: str) -> str:
 
         :param str name: ENS name to look up
         :param str key: ENS name's text record key
-        :return:  ENS name's text record value
+        :return: ENS name's text record value
         :rtype: str
-        :raises UnownedName: if no one owns `name`
+        :raises UnsupportedFunction: If the resolver does not support the "0x59d1d43c" interface id
+        :raises ResolverNotFound: If no resolver is found for the provided name
         """
         node = raw_name_to_hash(name)
         normal_name = normalize_name(name)
 
         r = self.resolver(normal_name)
         if r:
-            return r.caller.text(node, key)
+            if _resolver_supports_interface(r, GET_TEXT_INTERFACE_ID):
+                return r.caller.text(node, key)
+            else:
+                raise UnsupportedFunction(
+                    f"Resolver for name {name} does not support `text` function."
+                )
         else:
-            raise UnownedName("claim domain using setup_address() first")
+            raise ResolverNotFound(
+                f"No resolver found for name `{name}`. It is likely the name contains an "
+                "unsupported top level domain (tld)."
+            )
 
     def set_text(
         self,
         name: str,
         key: str,
         value: str,
-        transact: "TxParams" = {}
+        transact: "TxParams" = None
     ) -> HexBytes:
         """
         Set the value of a text record of an ENS name.
 
         :param str name: ENS name
         :param str key: Name of the attribute to set
         :param str value: Value to set the attribute to
-        :param dict transact: the transaction configuration, like in
+        :param dict transact: The transaction configuration, like in
             :meth:`~web3.eth.Eth.send_transaction`
         :return: Transaction hash
         :rtype: HexBytes
-        :raises UnownedName: if no one owns `name`
+        :raises UnsupportedFunction: If the resolver does not support the "0x59d1d43c" interface id
+        :raises ResolverNotFound: If no resolver is found for the provided name
         """
+        if not transact:
+            transact = {}
+
         owner = self.owner(name)
         node = raw_name_to_hash(name)
         normal_name = normalize_name(name)
@@ -335,16 +393,24 @@ def set_text(
 
         r = self.resolver(normal_name)
         if r:
-            return r.functions.setText(node, key, value).transact(transaction_dict)
+            if _resolver_supports_interface(r, GET_TEXT_INTERFACE_ID):
+                return r.functions.setText(node, key, value).transact(transaction_dict)
+            else:
+                raise UnsupportedFunction(
+                    f"Resolver for name `{name}` does not support `text` function"
+                )
         else:
-            raise UnownedName("claim domain using setup_address() first")
+            raise ResolverNotFound(
+                f"No resolver found for name `{name}`. It is likely the name contains an "
+                "unsupported top level domain (tld)."
+            )
 
     def setup_owner(
         self,
         name: str,
         new_owner: ChecksumAddress = cast(ChecksumAddress, default),
         transact: Optional["TxParams"] = None
-    ) -> ChecksumAddress:
+    ) -> Optional[ChecksumAddress]:
         """
         Set the owner of the supplied name to `new_owner`.
 
@@ -449,21 +515,53 @@ def _set_resolver(
                 namehash,
                 resolver_addr
             ).transact(transact)
-        return self._resolverContract(address=resolver_addr)
+        return self._resolver_contract(address=resolver_addr)
+
+    def _get_resolver(
+        self,
+        normal_name: str,
+        func: str = 'addr'
+    ) -> Tuple[Optional['Contract'], str]:
+        current_name = normal_name
+
+        # look for a resolver, starting at the full name and taking the parent each time that no
+        # resolver is found
+        while True:
+            if is_empty_name(current_name):
+                # if no resolver found across all iterations, current_name will eventually be the
+                # empty string '' which returns here
+                return None, current_name
+
+            resolver_addr = self.ens.caller.resolver(normal_name_to_hash(current_name))
+            if not is_none_or_zero_address(resolver_addr):
+                # if resolver found, return it
+                return self._type_aware_resolver(resolver_addr, func), current_name
+
+            # set current_name to parent and try again
+            current_name = self.parent(current_name)
 
     def _setup_reverse(
         self, name: str, address: ChecksumAddress, transact: Optional["TxParams"] = None
     ) -> HexBytes:
+        name = normalize_name(name) if name else ''
         if not transact:
             transact = {}
         transact = deepcopy(transact)
-        if name:
-            name = normalize_name(name)
-        else:
-            name = ''
         transact['from'] = address
         return self._reverse_registrar().functions.setName(name).transact(transact)
 
+    def _type_aware_resolver(self, address: ChecksumAddress, func: str) -> 'Contract':
+        return (
+            self._reverse_resolver_contract(address=address) if func == 'name' else
+            self._resolver_contract(address=address)
+        )
+
     def _reverse_registrar(self) -> 'Contract':
         addr = self.ens.caller.owner(normal_name_to_hash(REVERSE_REGISTRAR_DOMAIN))
         return self.w3.eth.contract(address=addr, abi=abis.REVERSE_REGISTRAR)
+
+
+def _resolver_supports_interface(resolver: 'Contract', interface_id: HexStr) -> bool:
+    if not any('supportsInterface' in repr(func) for func in resolver.all_functions()):
+        return False
+    return resolver.caller.supportsInterface(interface_id)