Merge branch 'main' into main

aries_cloudagent/connections/base_manager.py

@@ -7,7 +7,13 @@
 import logging
 from typing import List, Sequence, Tuple
 
-from pydid import DIDCommService, DIDDocument as ResolvedDocument, VerificationMethod
+from pydid import (
+    BaseDIDDocument as ResolvedDocument,
+    DIDCommService,
+    VerificationMethod,
+)
+import pydid
+from pydid.verification_method import Ed25519VerificationKey2018
 
 from ..core.error import BaseError
 from ..core.profile import ProfileSession
@@ -39,7 +45,7 @@ class BaseConnectionManager:
 
     RECORD_TYPE_DID_DOC = "did_doc"
     RECORD_TYPE_DID_KEY = "did_key"
-    SUPPORTED_KEY_TYPES = (PublicKeyType.ED25519_SIG_2018.ver_type,)
+    SUPPORTED_KEY_TYPES = (Ed25519VerificationKey2018,)
 
     def __init__(self, session: ProfileSession):
         """
@@ -221,7 +227,8 @@ async def resolve_invitation(self, did: str):
 
         resolver = self._session.inject(DIDResolver)
         try:
-            doc: ResolvedDocument = await resolver.resolve(self._session.profile, did)
+            doc_dict: dict = await resolver.resolve(self._session.profile, did)
+            doc: ResolvedDocument = pydid.deserialize_document(doc_dict, strict=True)
         except ResolverError as error:
             raise BaseConnectionManagerError(
                 "Failed to resolve public DID in invitation"
@@ -244,7 +251,7 @@ async def resolve_invitation(self, did: str):
 
         first_didcomm_service, *_ = didcomm_services
 
-        endpoint = first_didcomm_service.endpoint
+        endpoint = first_didcomm_service.service_endpoint
         recipient_keys: List[VerificationMethod] = [
             doc.dereference(url) for url in first_didcomm_service.recipient_keys
         ]
@@ -253,9 +260,9 @@ async def resolve_invitation(self, did: str):
         ]
 
         for key in [*recipient_keys, *routing_keys]:
-            if key.suite.type not in self.SUPPORTED_KEY_TYPES:
+            if not isinstance(key, self.SUPPORTED_KEY_TYPES):
                 raise BaseConnectionManagerError(
-                    f"Key type {key.suite.type} is not supported"
+                    f"Key type {key.type} is not supported"
                 )
 
         return (

aries_cloudagent/messaging/jsonld/routes.py

@@ -3,7 +3,7 @@
 from aiohttp import web
 from aiohttp_apispec import docs, request_schema, response_schema
 from marshmallow import INCLUDE, Schema, fields
-from pydid.doc.verification_method import VerificationMethod
+from pydid import VerificationMethod
 
 from ...admin.request_context import AdminRequestContext
 from ...config.base import InjectionError

aries_cloudagent/messaging/jsonld/tests/test_routes.py

@@ -1,40 +1,39 @@
-import json
-import pytest
-
 from copy import deepcopy
-
-from pydid.doc.service import Service
+import json
 
 from aiohttp import web
 from asynctest import TestCase as AsyncTestCase
 from asynctest import mock as async_mock
-from pydid import DIDDocument
+from pydid import DIDDocument, Service
 from pyld import jsonld
+import pytest
 
+from .. import routes as test_module
 from ....admin.request_context import AdminRequestContext
-from ....wallet.key_type import KeyType
-from ....wallet.did_method import DIDMethod
 from ....config.base import InjectionError
 from ....resolver.base import DIDMethodNotSupported, DIDNotFound, ResolverError
 from ....resolver.did_resolver import DIDResolver
 from ....resolver.tests import DOC
+from ....vc.ld_proofs.document_loader import DocumentLoader
 from ....wallet.base import BaseWallet
+from ....wallet.did_method import DIDMethod
 from ....wallet.error import WalletError
-from ....vc.ld_proofs.document_loader import DocumentLoader
-from .document_loader import custom_document_loader
-
-from .. import routes as test_module
+from ....wallet.key_type import KeyType
 from ..error import (
     BadJWSHeaderError,
     DroppedAttributeError,
     MissingVerificationMethodError,
 )
+from .document_loader import custom_document_loader
 
-did_doc = DIDDocument.deserialize(DOC)
+
+@pytest.fixture
+def did_doc():
+    yield DIDDocument.deserialize(DOC)
 
 
 @pytest.fixture
-def mock_resolver():
+def mock_resolver(did_doc):
     did_resolver = async_mock.MagicMock()
     did_resolver.resolve = async_mock.CoroutineMock(return_value=did_doc)
     url = "did:example:1234abcd#4"

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

@@ -1,38 +1,38 @@
 from unittest.mock import call
-from asynctest import mock as async_mock, TestCase as AsyncTestCase
+
+from asynctest import TestCase as AsyncTestCase, mock as async_mock
+from pydid import DIDDocument, DIDDocumentBuilder
+from pydid.verification_method import Ed25519VerificationKey2018, JsonWebKey2020
 
 from .....cache.base import BaseCache
 from .....cache.in_memory import InMemoryCache
 from .....config.base import InjectionError
+from .....connections.base_manager import BaseConnectionManagerError
 from .....connections.models.conn_record import ConnRecord
 from .....connections.models.connection_target import ConnectionTarget
-from .....connections.base_manager import (
-    BaseConnectionManagerError,
-)
 from .....connections.models.diddoc import DIDDoc, PublicKey, PublicKeyType, Service
-from pydid import DIDDocumentBuilder, VerificationSuite, DIDDocument, options
 from .....core.in_memory import InMemoryProfile
+from .....did.did_key import DIDKey
 from .....messaging.responder import BaseResponder, MockResponder
+from .....multitenant.manager import MultitenantManager
 from .....protocols.routing.v1_0.manager import RoutingManager
 from .....resolver.did_resolver import DIDResolver
 from .....resolver.did_resolver_registry import DIDResolverRegistry
 from .....storage.error import StorageNotFoundError
 from .....transport.inbound.receipt import MessageReceipt
 from .....wallet.base import DIDInfo
 from .....wallet.did_info import KeyInfo
+from .....wallet.did_method import DIDMethod
 from .....wallet.error import WalletNotFoundError
 from .....wallet.in_memory import InMemoryWallet
 from .....wallet.key_type import KeyType
-from .....wallet.did_method import DIDMethod
-from .....did.did_key import DIDKey
-from ....coordinate_mediation.v1_0.models.mediation_record import MediationRecord
 from ....coordinate_mediation.v1_0.manager import MediationManager
-from ....coordinate_mediation.v1_0.messages.keylist_update import KeylistUpdate
-from ....coordinate_mediation.v1_0.messages.mediate_request import MediationRequest
 from ....coordinate_mediation.v1_0.messages.inner.keylist_update_rule import (
     KeylistUpdateRule,
 )
-from .....multitenant.manager import MultitenantManager
+from ....coordinate_mediation.v1_0.messages.keylist_update import KeylistUpdate
+from ....coordinate_mediation.v1_0.messages.mediate_request import MediationRequest
+from ....coordinate_mediation.v1_0.models.mediation_record import MediationRecord
 from ..manager import ConnectionManager, ConnectionManagerError
 from ..messages.connection_invitation import ConnectionInvitation
 from ..messages.connection_request import ConnectionRequest
@@ -2148,14 +2148,12 @@ async def test_fetch_connection_targets_conn_invitation_did_no_resolver(self):
 
     async def test_fetch_connection_targets_conn_invitation_did_resolver(self):
         builder = DIDDocumentBuilder("did:sov:" + self.test_target_did)
-        vmethod = builder.verification_methods.add(
-            ident="1",
-            suite=VerificationSuite("Ed25519VerificationKey2018", "publicKeyBase58"),
-            material=self.test_target_verkey,
+        vmethod = builder.verification_method.add(
+            Ed25519VerificationKey2018, public_key_base58=self.test_target_verkey
         )
-        builder.services.add_didcomm(
+        builder.service.add_didcomm(
             ident="did-communication",
-            endpoint=self.test_endpoint,
+            service_endpoint=self.test_endpoint,
             recipient_keys=[vmethod],
         )
         did_doc = builder.build()
@@ -2202,32 +2200,29 @@ async def test_fetch_connection_targets_conn_invitation_did_resolver(self):
 
     async def test_fetch_connection_targets_conn_invitation_btcr_resolver(self):
         builder = DIDDocumentBuilder("did:btcr:x705-jznz-q3nl-srs")
-        vmethod = builder.verification_methods.add(
-            ident="1",
-            suite=VerificationSuite("Ed25519VerificationKey2018", "publicKeyBase58"),
-            material="02e0e01a8c302976e1556e95c54146e8464adac8626a5d29474718a7281133ff49",
-        )
-        with builder.services.defaults() as services:
-            services.add_didcomm(
-                type_="IndyAgent",
-                recipient_keys=[vmethod],
-                routing_keys=[vmethod],
-                endpoint=self.test_endpoint,
-                # priority=1, # TODO: add back in after pydid update
-            )
-
-            services.add_didcomm(
-                recipient_keys=[vmethod],
-                routing_keys=[vmethod],
-                endpoint=self.test_endpoint,
-                # priority=0, # TODO: add back in after pydid update
-            )
-            services.add_didcomm(
-                recipient_keys=[vmethod],
-                routing_keys=[vmethod],
-                endpoint="{}/priority2".format(self.test_endpoint),
-                # priority=2, # TODO: add back in after pydid update
-            )
+        vmethod = builder.verification_method.add(
+            Ed25519VerificationKey2018, public_key_base58=self.test_target_verkey
+        )
+        builder.service.add_didcomm(
+            type_="IndyAgent",
+            recipient_keys=[vmethod],
+            routing_keys=[vmethod],
+            service_endpoint=self.test_endpoint,
+            priority=1,
+        )
+
+        builder.service.add_didcomm(
+            recipient_keys=[vmethod],
+            routing_keys=[vmethod],
+            service_endpoint=self.test_endpoint,
+            priority=0,
+        )
+        builder.service.add_didcomm(
+            recipient_keys=[vmethod],
+            routing_keys=[vmethod],
+            service_endpoint="{}/priority2".format(self.test_endpoint),
+            priority=2,
+        )
         did_doc = builder.build()
 
         self.resolver = async_mock.MagicMock()
@@ -2293,10 +2288,7 @@ async def test_fetch_connection_targets_conn_invitation_btcr_without_services(se
                 },
             ],
         }
-        # TODO: move options
-        did_doc = DIDDocument.deserialize(
-            did_doc_json, options={options.vm_allow_missing_controller}
-        )
+        did_doc = DIDDocument.deserialize(did_doc_json)
         self.resolver = async_mock.MagicMock()
         self.resolver.get_endpoint_for_did = async_mock.CoroutineMock(
             return_value=self.test_endpoint
@@ -2332,16 +2324,10 @@ async def test_fetch_connection_targets_conn_invitation_btcr_without_services(se
 
     async def test_fetch_connection_targets_conn_invitation_no_didcomm_services(self):
         builder = DIDDocumentBuilder("did:btcr:x705-jznz-q3nl-srs")
-        vmethod = builder.verification_methods.add(
-            ident="1",
-            suite=VerificationSuite("Ed25519VerificationKey2018", "publicKeyBase58"),
-            material="02e0e01a8c302976e1556e95c54146e8464adac8626a5d29474718a7281133ff49",
+        builder.verification_method.add(
+            Ed25519VerificationKey2018, public_key_base58=self.test_target_verkey
         )
-        with builder.services.defaults() as services:
-            services.add(
-                type_="LinkedData",
-                endpoint=self.test_endpoint,
-            )
+        builder.service.add(type_="LinkedData", service_endpoint=self.test_endpoint)
         did_doc = builder.build()
         self.resolver = async_mock.MagicMock()
         self.resolver.get_endpoint_for_did = async_mock.CoroutineMock(
@@ -2350,7 +2336,7 @@ async def test_fetch_connection_targets_conn_invitation_no_didcomm_services(self
         self.resolver.resolve = async_mock.CoroutineMock(return_value=did_doc)
         self.context.injector.bind_instance(DIDResolver, self.resolver)
 
-        local_did = await self.session.wallet.create_local_did(
+        await self.session.wallet.create_local_did(
             method=DIDMethod.SOV,
             key_type=KeyType.ED25519,
             seed=self.test_seed,
@@ -2378,15 +2364,16 @@ async def test_fetch_connection_targets_conn_invitation_no_didcomm_services(self
 
     async def test_fetch_connection_targets_conn_invitation_unsupported_key_type(self):
         builder = DIDDocumentBuilder("did:btcr:x705-jznz-q3nl-srs")
-        vmethod = builder.verification_methods.add(
+        vmethod = builder.verification_method.add(
+            JsonWebKey2020,
             ident="1",
-            suite=VerificationSuite("JsonWebKey2020", "publicKeyJwk"),
-            material={"jwk": "stuff"},
+            public_key_jwk={"jwk": "stuff"},
+        )
+        builder.service.add_didcomm(
+            type_="IndyAgent",
+            service_endpoint=self.test_endpoint,
+            recipient_keys=[vmethod],
         )
-        with builder.services.defaults() as services:
-            services.add_didcomm(
-                type_="IndyAgent", endpoint=self.test_endpoint, recipient_keys=[vmethod]
-            )
         did_doc = builder.build()
         self.resolver = async_mock.MagicMock()
         self.resolver.get_endpoint_for_did = async_mock.CoroutineMock(
@@ -2448,14 +2435,14 @@ async def test_fetch_connection_targets_oob_invitation_svc_did_no_resolver(self)
 
     async def test_fetch_connection_targets_oob_invitation_svc_did_resolver(self):
         builder = DIDDocumentBuilder("did:sov:" + self.test_target_did)
-        vmethod = builder.verification_methods.add(
+        vmethod = builder.verification_method.add(
+            Ed25519VerificationKey2018,
             ident="1",
-            suite=VerificationSuite("Ed25519VerificationKey2018", "publicKeyBase58"),
-            material=self.test_target_verkey,
+            public_key_base58=self.test_target_verkey,
         )
-        builder.services.add_didcomm(
+        builder.service.add_didcomm(
             ident="did-communication",
-            endpoint=self.test_endpoint,
+            service_endpoint=self.test_endpoint,
             recipient_keys=[vmethod],
         )
         did_doc = builder.build()

aries_cloudagent/resolver/base.py

@@ -6,14 +6,7 @@
 from typing import NamedTuple, Pattern, Sequence, Union
 import warnings
 
-from pydid import DID, DIDDocument
-from pydid.options import (
-    doc_allow_public_key,
-    doc_insert_missing_ids,
-    vm_allow_controller_list,
-    vm_allow_missing_controller,
-    vm_allow_type_list,
-)
+from pydid import DID
 
 from ..config.injection_context import InjectionContext
 from ..core.error import BaseError
@@ -55,7 +48,7 @@ def serialize(self) -> dict:
 class ResolutionResult:
     """Resolution Class to pack the DID Doc and the resolution information."""
 
-    def __init__(self, did_document: DIDDocument, metadata: ResolutionMetadata):
+    def __init__(self, did_document: dict, metadata: ResolutionMetadata):
         """Initialize Resolution.
 
         Args:
@@ -68,7 +61,7 @@ def __init__(self, did_document: DIDDocument, metadata: ResolutionMetadata):
     def serialize(self) -> dict:
         """Return serialized resolution result."""
         return {
-            "did_document": self.did_document.serialize(),
+            "did_document": self.did_document,
             "metadata": self.metadata.serialize(),
         }
 
@@ -137,7 +130,7 @@ async def supports(self, profile: Profile, did: str) -> bool:
 
         return bool(supported_did_regex.match(did))
 
-    async def resolve(self, profile: Profile, did: Union[str, DID]) -> DIDDocument:
+    async def resolve(self, profile: Profile, did: Union[str, DID]) -> dict:
         """Resolve a DID using this resolver."""
         if isinstance(did, DID):
             did = str(did)
@@ -148,17 +141,7 @@ async def resolve(self, profile: Profile, did: Union[str, DID]) -> DIDDocument:
                 f"{self.__class__.__name__} does not support DID method for: {did}"
             )
 
-        doc_dict = await self._resolve(profile, did)
-        return DIDDocument.deserialize(
-            doc_dict,
-            options={
-                doc_insert_missing_ids,
-                doc_allow_public_key,
-                vm_allow_controller_list,
-                vm_allow_missing_controller,
-                vm_allow_type_list,
-            },
-        )
+        return await self._resolve(profile, did)
 
     @abstractmethod
     async def _resolve(self, profile: Profile, did: str) -> dict: