did-exchange implicit request pthid update & invitation key verification

aries_cloudagent/protocols/didexchange/v1_0/manager.py

@@ -2,6 +2,9 @@
 
 import json
 import logging
+import pydid
+
+from pydid import BaseDIDDocument as ResolvedDocument
 
 from ....connections.models.conn_record import ConnRecord
 from ....connections.models.diddoc import DIDDoc
@@ -12,6 +15,8 @@
 from ....messaging.decorators.attach_decorator import AttachDecorator
 from ....messaging.responder import BaseResponder
 from ....multitenant.base import BaseMultitenantManager
+from ....resolver.base import ResolverError
+from ....resolver.did_resolver import DIDResolver
 from ....storage.error import StorageNotFoundError
 from ....transport.inbound.receipt import MessageReceipt
 from ....wallet.base import BaseWallet
@@ -296,14 +301,22 @@ async def create_request(
                 filter(None, [base_mediation_record, mediation_record])
             ),
         )
-        if (
-            conn_rec.their_public_did is not None
-            and conn_rec.their_public_did.startswith("did:")
-        ):
+        if conn_rec.their_public_did is not None:
             qualified_did = conn_rec.their_public_did
-        else:
-            qualified_did = f"did:sov:{conn_rec.their_public_did}"
-        pthid = conn_rec.invitation_msg_id or qualified_did
+            if not conn_rec.their_public_did.startswith("did:"):
+                qualified_did = f"did:sov:{conn_rec.their_public_did}"
+            resolver = self._profile.inject(DIDResolver)
+            try:
+                doc_dict: dict = await resolver.resolve(self._profile, qualified_did)
+                doc: ResolvedDocument = pydid.deserialize_document(
+                    doc_dict, strict=True
+                )
+                did_url = doc.service[0].id
+            except ResolverError as error:
+                raise DIDXManagerError(
+                    "Failed to resolve public DID in invitation"
+                ) from error
+        pthid = conn_rec.invitation_msg_id or did_url
         attach = AttachDecorator.data_base64(did_doc.serialize())
         async with self.profile.session() as session:
             wallet = session.inject(BaseWallet)

aries_cloudagent/protocols/didexchange/v1_0/tests/test_manager.py

@@ -1,6 +1,7 @@
 import json
 
 from asynctest import mock as async_mock, TestCase as AsyncTestCase
+from pydid import DIDDocument
 
 from .....cache.base import BaseCache
 from .....cache.in_memory import InMemoryCache
@@ -18,6 +19,9 @@
 from .....messaging.decorators.attach_decorator import AttachDecorator
 from .....multitenant.base import BaseMultitenantManager
 from .....multitenant.manager import MultitenantManager
+from .....resolver.base import ResolverError
+from .....resolver.did_resolver import DIDResolver
+from .....resolver.tests import DOC
 from .....storage.error import StorageNotFoundError
 from .....transport.inbound.receipt import MessageReceipt
 from .....wallet.did_info import DIDInfo
@@ -102,6 +106,10 @@ async def setUp(self):
             return_value=TestConfig.test_endpoint
         )
         self.context.injector.bind_instance(BaseLedger, self.ledger)
+        self.resolver = async_mock.MagicMock()
+        did_doc = DIDDocument.deserialize(DOC)
+        self.resolver.resolve = async_mock.CoroutineMock(return_value=did_doc)
+        self.context.injector.bind_instance(DIDResolver, self.resolver)
 
         self.multitenant_mgr = async_mock.MagicMock(MultitenantManager, autospec=True)
         self.context.injector.bind_instance(
@@ -266,6 +274,27 @@ async def test_create_request_implicit_use_public_did(self):
 
             assert info_public.did == conn_rec.my_did
 
+    async def test_create_request_implicit_resolver_error(self):
+        async with self.profile.session() as session:
+            await session.wallet.create_public_did(
+                DIDMethod.SOV,
+                KeyType.ED25519,
+            )
+        with async_mock.patch.object(
+            self.resolver,
+            "resolve",
+            async_mock.CoroutineMock(side_effect=ResolverError()),
+        ):
+            with self.assertRaises(DIDXManagerError) as ctx:
+                conn_rec = await self.manager.create_request_implicit(
+                    their_public_did=TestConfig.test_target_did,
+                    my_label=None,
+                    my_endpoint=None,
+                    use_public_did=True,
+                    alias="Tester",
+                )
+            assert "Failed to resolve public DID in invitation" in str(ctx.exception)
+
     async def test_create_request_implicit_no_public_did(self):
         with self.assertRaises(WalletError) as context:
             await self.manager.create_request_implicit(
@@ -292,6 +321,7 @@ async def test_create_request(self):
                 )
             ),
             save=async_mock.CoroutineMock(),
+            their_public_did=None,
         )
 
         with async_mock.patch.object(
@@ -345,6 +375,7 @@ async def test_create_request_multitenant(self):
                         )
                     ),
                     save=async_mock.CoroutineMock(),
+                    their_public_did=None,
                 )
             )
 
@@ -419,6 +450,7 @@ async def test_create_request_my_endpoint(self):
                 )
             ),
             save=async_mock.CoroutineMock(),
+            their_public_did=None,
         )
 
         with async_mock.patch.object(