Pluggable DID Resolver Interface (cleaned)

aries_cloudagent/config/default_context.py

@@ -9,6 +9,8 @@
 from ..core.plugin_registry import PluginRegistry
 from ..core.profile import ProfileManager, ProfileManagerProvider
 from ..core.protocol_registry import ProtocolRegistry
+from ..resolver.did_resolver import DIDResolver
+from ..resolver.did_resolver_registry import DIDResolverRegistry
 from ..tails.base import BaseTailsServer
 from ..ledger.indy import IndySdkLedgerPool, IndySdkLedgerPoolProvider
 
@@ -17,7 +19,6 @@
 from ..protocols.didcomm_prefix import DIDCommPrefix
 from ..protocols.introduction.v0_1.base_service import BaseIntroductionService
 from ..protocols.introduction.v0_1.demo_service import DemoIntroductionService
-
 from ..transport.wire_format import BaseWireFormat
 from ..utils.stats import Collector
 
@@ -41,6 +42,13 @@ async def build_context(self) -> InjectionContext:
         # Global protocol registry
         context.injector.bind_instance(ProtocolRegistry, ProtocolRegistry())
 
+        # Global did resolver registry
+        did_resolver_registry = DIDResolverRegistry()
+        context.injector.bind_instance(DIDResolverRegistry, did_resolver_registry)
+
+        # Global did resolver
+        context.injector.bind_instance(DIDResolver, DIDResolver(did_resolver_registry))
+
         await self.bind_providers(context)
         await self.load_plugins(context)
 
@@ -103,7 +111,9 @@ async def load_plugins(self, context: InjectionContext):
             "aries_cloudagent.messaging.credential_definitions"
         )
         plugin_registry.register_plugin("aries_cloudagent.messaging.schemas")
+        # plugin_registry.register_plugin("aries_cloudagent.messaging.jsonld")
         plugin_registry.register_plugin("aries_cloudagent.revocation")
+        plugin_registry.register_plugin("aries_cloudagent.resolver")
         plugin_registry.register_plugin("aries_cloudagent.wallet")
 
         if context.settings.get("multitenant.admin_enabled"):

aries_cloudagent/resolver/__init__.py

@@ -0,0 +1,27 @@
+"""Interfaces and base classes for DID Resolution."""
+
+import logging
+
+from ..config.injection_context import InjectionContext
+from ..config.provider import ClassProvider
+from .did_resolver_registry import DIDResolverRegistry
+
+LOGGER = logging.getLogger(__name__)
+
+
+async def setup(context: InjectionContext):
+    """Set up default resolvers."""
+    registry = context.inject(DIDResolverRegistry, required=False)
+    if not registry:
+        LOGGER.warning("No DID Resolver Registry instance found in context")
+        return
+
+    if context.settings.get("ledger.disabled"):
+        LOGGER.warning("Ledger is not configured, not loading IndyDIDResolver")
+        return
+
+    resolver = ClassProvider(
+        "aries_cloudagent.resolver.default.indy.IndyDIDResolver"
+    ).provide(context.settings, context.injector)
+    await resolver.setup(context)
+    registry.register(resolver)

aries_cloudagent/resolver/base.py

@@ -0,0 +1,79 @@
+"""Base Class for DID Resolvers."""
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Sequence, Union
+
+from pydid import DID, DIDDocument
+
+from ..config.injection_context import InjectionContext
+from ..core.error import BaseError
+from ..core.profile import Profile
+
+
+class ResolverError(BaseError):
+    """Base class for resolver exceptions."""
+
+
+class DIDNotFound(ResolverError):
+    """Raised when DID is not found in verifiable data registry."""
+
+
+class DIDMethodNotSupported(ResolverError):
+    """Raised when no resolver is registered for a given did method."""
+
+
+class ResolverType(Enum):
+    """Resolver Type declarations."""
+
+    NATIVE = "native"
+    NON_NATIVE = "non-native"
+
+
+class BaseDIDResolver(ABC):
+    """Base Class for DID Resolvers."""
+
+    def __init__(self, type_: ResolverType = None):
+        """Initialize BaseDIDResolver.
+
+        Args:
+            type_ (Type): Type of resolver, native or non-native
+        """
+        self.type = type_ or ResolverType.NON_NATIVE
+
+    @abstractmethod
+    async def setup(self, context: InjectionContext):
+        """Do asynchronous resolver setup."""
+
+    @property
+    def native(self):
+        """Return if this resolver is native."""
+        return self.type == ResolverType.NATIVE
+
+    @property
+    @abstractmethod
+    def supported_methods(self) -> Sequence[str]:
+        """Return list of DID methods supported by this resolver."""
+
+    def supports(self, method: str) -> bool:
+        """Return if this resolver supports the given method."""
+        return method in self.supported_methods
+
+    async def resolve(self, profile: Profile, did: Union[str, DID]) -> DIDDocument:
+        """Resolve a DID using this resolver."""
+        if isinstance(did, str):
+            did = DID(did)
+
+        if not self.supports(did.method):
+            raise DIDMethodNotSupported(
+                f"{did.method} is not supported by {self.__class__.__name__} resolver."
+            )
+
+        did = str(did)
+        did_document = await self._resolve(profile, did)
+        result = DIDDocument.deserialize(did_document)
+        return result
+
+    @abstractmethod
+    async def _resolve(self, profile: Profile, did: DID) -> dict:
+        """Resolve a DID using this resolver."""

aries_cloudagent/resolver/default/__init__.py

@@ -0,0 +1 @@
+"""Resolvers included in ACA-Py by Default."""

aries_cloudagent/resolver/default/indy.py

@@ -0,0 +1,70 @@
+"""Indy DID Resolver.
+
+Resolution is performed using the IndyLedger class.
+"""
+from typing import Sequence
+
+from pydid import DID, DIDDocumentBuilder, VerificationSuite
+
+from ...config.injection_context import InjectionContext
+from ...core.profile import Profile
+from ...ledger.indy import IndySdkLedger
+from ...ledger.base import BaseLedger
+from ...ledger.error import LedgerError
+from ..base import BaseDIDResolver, DIDNotFound, ResolverError, ResolverType
+
+
+class NoIndyLedger(ResolverError):
+    """Raised when there is no indy ledger instance configured."""
+
+
+class IndyDIDResolver(BaseDIDResolver):
+    """Indy DID Resolver."""
+
+    VERIFICATION_METHOD_TYPE = "Ed25519VerificationKey2018"
+    AGENT_SERVICE_TYPE = "did-communication"
+    SUITE = VerificationSuite(VERIFICATION_METHOD_TYPE, "publicKeyBase58")
+
+    def __init__(self):
+        """Initialize Indy Resolver."""
+        super().__init__(ResolverType.NATIVE)
+
+    async def setup(self, context: InjectionContext):
+        """Perform required setup for Indy DID resolution."""
+
+    @property
+    def supported_methods(self) -> Sequence[str]:
+        """Return supported methods of Indy DID Resolver."""
+        return ["sov"]
+
+    async def _resolve(self, profile: Profile, did: str) -> dict:
+        """Resolve an indy DID."""
+        did = DID(did)
+        ledger = profile.inject(BaseLedger, required=False)
+        if not ledger or not isinstance(ledger, IndySdkLedger):
+            raise NoIndyLedger("No Indy ledger instance is configured.")
+
+        try:
+            async with ledger:
+                recipient_key = await ledger.get_key_for_did(did)
+                endpoint = await ledger.get_endpoint_for_did(did)
+        except LedgerError as err:
+            raise DIDNotFound(f"DID {did} could not be resolved") from err
+
+        builder = DIDDocumentBuilder(did)
+
+        vmethod = builder.verification_methods.add(
+            ident="keys-1", suite=self.SUITE, material=recipient_key
+        )
+        builder.authentication.reference(vmethod.id)
+        if endpoint:
+            # TODO add priority
+            builder.services.add_didcomm(
+                ident=self.AGENT_SERVICE_TYPE,
+                type_=self.AGENT_SERVICE_TYPE,
+                endpoint=endpoint,
+                recipient_keys=[vmethod],
+                routing_keys=[],
+            )
+        result = builder.build()
+        return result.serialize()

aries_cloudagent/resolver/default/tests/test_indy.py

@@ -0,0 +1,70 @@
+"""Test IndyDIDResolver."""
+
+import pytest
+from asynctest import mock as async_mock
+
+from ....core.in_memory import InMemoryProfile
+from ....core.profile import Profile
+from ....ledger.base import BaseLedger
+from ....ledger.error import LedgerError
+from ...base import DIDNotFound, ResolverError
+from .. import indy as test_module
+from ..indy import IndyDIDResolver
+
+# pylint: disable=W0621
+TEST_DID0 = "did:sov:123"
+
+
+@pytest.fixture
+def resolver():
+    """Resolver fixture."""
+    yield IndyDIDResolver()
+
+
+@pytest.fixture
+def ledger():
+    """Ledger fixture."""
+    ledger = async_mock.MagicMock(spec=test_module.IndySdkLedger)
+    ledger.get_endpoint_for_did = async_mock.CoroutineMock(
+        return_value="https://github.com/"
+    )
+    ledger.get_key_for_did = async_mock.CoroutineMock(return_value="key")
+    yield ledger
+
+
+@pytest.fixture
+def profile(ledger):
+    """Profile fixture."""
+    profile = InMemoryProfile.test_profile()
+    profile.context.injector.bind_instance(BaseLedger, ledger)
+    yield profile
+
+
+def test_supported_methods(resolver: IndyDIDResolver):
+    """Test the supported_methods."""
+    assert resolver.supported_methods == ["sov"]
+    assert resolver.supports("sov")
+
+
+@pytest.mark.asyncio
+async def test_resolve(resolver: IndyDIDResolver, profile: Profile):
+    """Test resolve method."""
+    assert await resolver.resolve(profile, TEST_DID0)
+
+
+@pytest.mark.asyncio
+async def test_resolve_x_no_ledger(resolver: IndyDIDResolver, profile: Profile):
+    """Test resolve method with no ledger."""
+    profile.context.injector.clear_binding(BaseLedger)
+    with pytest.raises(ResolverError):
+        await resolver.resolve(profile, TEST_DID0)
+
+
+@pytest.mark.asyncio
+async def test_resolve_x_did_not_found(
+    resolver: IndyDIDResolver, ledger: BaseLedger, profile: Profile
+):
+    """Test resolve method when no did is found."""
+    ledger.get_key_for_did.side_effect = LedgerError
+    with pytest.raises(DIDNotFound):
+        await resolver.resolve(profile, TEST_DID0)

aries_cloudagent/resolver/did_resolver.py

@@ -0,0 +1,70 @@
+"""
+the did resolver.
+
+responsible for keeping track of all resolvers. more importantly
+retrieving did's from different sources provided by the method type.
+"""
+
+import logging
+from itertools import chain
+from typing import Union
+
+from pydid import DID, DIDUrl, DIDDocument, Service, VerificationMethod
+
+from ..core.profile import Profile
+from ..resolver.base import BaseDIDResolver, DIDMethodNotSupported, DIDNotFound
+from .did_resolver_registry import DIDResolverRegistry
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DIDResolver:
+    """did resolver singleton."""
+
+    def __init__(self, registry: DIDResolverRegistry):
+        """Initialize a `didresolver` instance."""
+        self.did_resolver_registry = registry
+
+    async def resolve(self, profile: Profile, did: Union[str, DID]) -> DIDDocument:
+        """Retrieve did doc from public registry."""
+        # TODO Cache results
+        if isinstance(did, str):
+            did = DID(did)
+        for resolver in self._match_did_to_resolver(did):
+            try:
+                LOGGER.debug("Resolving DID %s with %s", did, resolver)
+                return await resolver.resolve(profile, did)
+            except DIDNotFound:
+                LOGGER.debug("DID %s not found by resolver %s", did, resolver)
+
+        raise DIDNotFound(f"DID {did} could not be resolved.")
+
+    def _match_did_to_resolver(self, did: DID) -> BaseDIDResolver:
+        """Generate supported DID Resolvers.
+
+        Native resolvers are yielded first, in registered order followed by
+        non-native resolvers in registered order.
+        """
+        valid_resolvers = list(
+            filter(
+                lambda resolver: resolver.supports(did.method),
+                self.did_resolver_registry.resolvers,
+            )
+        )
+        native_resolvers = filter(lambda resolver: resolver.native, valid_resolvers)
+        non_native_resolvers = filter(
+            lambda resolver: not resolver.native, valid_resolvers
+        )
+        resolvers = list(chain(native_resolvers, non_native_resolvers))
+        if not resolvers:
+            raise DIDMethodNotSupported(f"DID method '{did.method}' not supported")
+        return resolvers
+
+    async def dereference(
+        self, profile: Profile, did_url: str
+    ) -> Union[Service, VerificationMethod]:
+        """Dereference a DID URL to its corresponding DID Doc object."""
+        # TODO Use cached DID Docs when possible
+        did_url = DIDUrl.parse(did_url)
+        doc = await self.resolve(profile, did_url.did)
+        return doc.dereference(did_url)

aries_cloudagent/resolver/did_resolver_registry.py

@@ -0,0 +1,26 @@
+"""In memmory storage for registering did resolvers."""
+
+import logging
+from typing import Sequence
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DIDResolverRegistry:
+    """Registry for did resolvers."""
+
+    def __init__(self):
+        """Initialize list for did resolvers."""
+        self._resolvers = []
+
+    @property
+    def resolvers(
+        self,
+    ) -> Sequence[str]:
+        """Accessor for a list of all did resolvers."""
+        return self._resolvers
+
+    def register(self, resolver) -> None:
+        """Register a resolver."""
+        LOGGER.debug("Registering resolver %s", resolver)
+        self._resolvers.append(resolver)