Use async dnspython methods for openalias/dnssec

electrum/contacts.py

@@ -22,16 +22,15 @@
 # SOFTWARE.
 import re
 from typing import Optional, Tuple, Dict, Any, TYPE_CHECKING
-
+import asyncio
 import dns
-import threading
 from dns.exception import DNSException
 
 from . import bitcoin
 from . import dnssec
 from .util import read_json_file, write_json_file, to_string, is_valid_email
 from .logging import Logger, get_logger
-from .util import trigger_callback
+from .util import trigger_callback, get_asyncio_loop
 
 if TYPE_CHECKING:
     from .wallet_db import WalletDB
@@ -85,7 +84,7 @@ class Contacts(dict, Logger):
             return res
         return None
 
-    def resolve(self, k):
+    async def resolve(self, k) -> dict:
         if bitcoin.is_address(k):
             return {
                 'address': k,
@@ -99,13 +98,13 @@ class Contacts(dict, Logger):
                     'address': address,
                     'type': 'contact'
                 }
-        if openalias := self.resolve_openalias(k):
+        if openalias := await self.resolve_openalias(k):
             return openalias
         raise AliasNotFoundException("Invalid Bitcoin address or alias", k)
 
     @classmethod
-    def resolve_openalias(cls, url: str) -> Dict[str, Any]:
-        out = cls._resolve_openalias(url)
+    async def resolve_openalias(cls, url: str) -> Dict[str, Any]:
+        out = await cls._resolve_openalias(url)
         if out:
             address, name, validated = out
             return {
@@ -132,19 +131,17 @@ class Contacts(dict, Logger):
         alias = config.OPENALIAS_ID
         if alias:
             alias = str(alias)
-            def f():
-                self.alias_info = self._resolve_openalias(alias)
+            async def f():
+                self.alias_info = await self._resolve_openalias(alias)
                 trigger_callback('alias_received')
-            t = threading.Thread(target=f)
-            t.daemon = True
-            t.start()
+            asyncio.run_coroutine_threadsafe(f(), get_asyncio_loop())
 
     @classmethod
-    def _resolve_openalias(cls, url: str) -> Optional[Tuple[str, str, bool]]:
+    async def _resolve_openalias(cls, url: str) -> Optional[Tuple[str, str, bool]]:
         # support email-style addresses, per the OA standard
         url = url.replace('@', '.')
         try:
-            records, validated = dnssec.query(url, dns.rdatatype.TXT)
+            records, validated = await dnssec.query(url, dns.rdatatype.TXT)
         except DNSException as e:
             _logger.info(f'Error resolving openalias: {repr(e)}')
             return None
@@ -161,7 +158,6 @@ class Contacts(dict, Logger):
                 if not address:
                     continue
                 return address, name, validated
-            return None
         return None
 
     @staticmethod