feat(WIP): anoncreds updates

.github/workflows/tests.yml

@@ -29,7 +29,8 @@ jobs:
             -r requirements.txt \
             -r requirements.askar.txt \
             -r requirements.bbs.txt \
-            -r requirements.dev.txt
+            -r requirements.dev.txt \
+            -r requirements.anoncreds.txt
       - name: Tests
         run: |
           pytest

anoncreds_test.py

@@ -0,0 +1,86 @@
+import os
+
+from controller.controller import Controller
+from controller.protocols import (
+    indy_anoncred_onboard,
+    didexchange,
+    indy_issue_credential_v2,
+    indy_present_proof_v2,
+)
+from controller.logging import logging_to_stdout
+
+ALICE = os.getenv("ALICE", "http://alice:3001")
+BOB = os.getenv("BOB", "http://bob:3005")
+
+
+async def main():
+    logging_to_stdout()
+    async with Controller(base_url=ALICE) as alice, Controller(base_url=BOB) as bob:
+        # DID Setup
+        public_did = await indy_anoncred_onboard(alice)
+
+        # Register a Schema using legacy Indy
+        response = await alice.post(
+            "/anoncreds/schema",
+            json={
+                "schema": {
+                    "attrNames": ["name", "age"],
+                    "issuerId": public_did.did,
+                    "name": "anoncreds-testing",
+                    "version": "0.1",
+                },
+                "options": {},
+            },
+        )
+        schema_id = response["schema_state"]["schema_id"]
+        schema = await alice.get(f"/anoncreds/schema/{schema_id}")
+        schemas = await alice.get("/anoncreds/schemas")
+
+        cred_def = await alice.post(
+            "/anoncreds/credential-definition",
+            json={
+                "credential_definition": {
+                    "tag": "default",
+                    "schemaId": schema_id,
+                    "issuerId": public_did.did,
+                },
+                "options": {
+                    "support_revocation": False,
+                },
+            },
+        )
+        cred_def_id = cred_def["credential_definition_state"][
+            "credential_definition_id"
+        ]
+        cred_def = await alice.get(f"/anoncreds/credential-definition/{cred_def_id}")
+        cred_defs = await alice.get("/anoncreds/credential-definitions")
+
+        alice_conn, bob_conn = await didexchange(alice, bob)
+        await indy_issue_credential_v2(
+            alice,
+            bob,
+            alice_conn.connection_id,
+            bob_conn.connection_id,
+            cred_def_id,
+            {"name": "Bob", "age": "42"},
+        )
+        bob_pres, alice_pres = await indy_present_proof_v2(
+            bob,
+            alice,
+            bob_conn.connection_id,
+            alice_conn.connection_id,
+            name="proof-1",
+            version="0.1",
+            comment="testing",
+            requested_attributes=[
+                {"name": "name", "restrictions": [{"cred_def_id": cred_def_id}]},
+                {"name": "age", "restrictions": [{"cred_def_id": cred_def_id}]},
+            ],
+        )
+        print(alice_pres.verified)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

aries_cloudagent/anoncreds/__init__.py

@@ -0,0 +1,42 @@
+import logging
+
+from ..config.injection_context import InjectionContext
+from ..config.provider import ClassProvider
+
+from .registry import AnonCredsRegistry
+
+LOGGER = logging.getLogger(__name__)
+
+
+async def setup(context: InjectionContext):
+    """Set up default resolvers."""
+    registry = context.inject_or(AnonCredsRegistry)
+    if not registry:
+        LOGGER.warning("No AnonCredsRegistry instance found in context")
+        return
+
+    indy_registry = ClassProvider(
+        "aries_cloudagent.anoncreds.default.did_indy.registry.DIDIndyRegistry",
+        # supported_identifiers=[],
+        # method_name="did:indy",
+    ).provide(context.settings, context.injector)
+    await indy_registry.setup(context)
+    registry.register(indy_registry)
+
+    web_registry = ClassProvider(
+        "aries_cloudagent.anoncreds.default.did_web.registry.DIDWebRegistry",
+        # supported_identifiers=[],
+        # method_name="did:web",
+    ).provide(context.settings, context.injector)
+    await web_registry.setup(context)
+    registry.register(web_registry)
+
+    legacy_indy_registry = ClassProvider(
+        "aries_cloudagent.anoncreds.default.legacy_indy.registry.LegacyIndyRegistry",
+        # supported_identifiers=[],
+        # method_name="",
+    ).provide(context.settings, context.injector)
+    await legacy_indy_registry.setup(context)
+    registry.register(legacy_indy_registry)
+
+    # TODO: add context.settings

aries_cloudagent/anoncreds/base.py

@@ -0,0 +1,155 @@
+"""Base Registry"""
+from abc import ABC, abstractmethod
+from typing import Generic, Optional, Pattern, Tuple, TypeVar
+
+from ..config.injection_context import InjectionContext
+from ..core.error import BaseError
+from ..core.profile import Profile
+from .models.anoncreds_cred_def import (
+    CredDef,
+    CredDefResult,
+    GetCredDefResult,
+)
+from .models.anoncreds_revocation import (
+    GetRevStatusListResult,
+    AnonCredsRegistryGetRevocationRegistryDefinition,
+    RevRegDef,
+    RevRegDefResult,
+    RevStatusList,
+    RevStatusListResult,
+)
+from .models.anoncreds_schema import AnonCredsSchema, GetSchemaResult, SchemaResult
+
+
+T = TypeVar("T")
+
+
+class BaseAnonCredsError(BaseError):
+    """Base error class for AnonCreds."""
+
+
+class AnonCredsObjectNotFound(BaseAnonCredsError):
+    """Raised when object is not found in resolver."""
+
+    def __init__(
+        self, message: Optional[str] = None, resolution_metadata: Optional[dict] = None
+    ):
+        super().__init__(message, resolution_metadata)
+        self.resolution_metadata = resolution_metadata
+
+
+class AnonCredsRegistrationError(BaseAnonCredsError):
+    """Raised when registering an AnonCreds object fails."""
+
+
+class AnonCredsObjectAlreadyExists(AnonCredsRegistrationError, Generic[T]):
+    """Raised when an AnonCreds object already exists."""
+
+    def __init__(
+        self, message: Optional[str] = None, obj: Optional[T] = None, *args, **kwargs
+    ):
+        super().__init__(message, obj, *args, **kwargs)
+        self.obj = obj
+
+    @property
+    def message(self):
+        if self.args[0] and self.args[1]:
+            return f"{self.args[0]}: {self.args[1]}"
+        else:
+            return super().message
+
+
+class AnonCredsSchemaAlreadyExists(
+    AnonCredsObjectAlreadyExists[Tuple[str, AnonCredsSchema]]
+):
+    """Raised when a schema already exists."""
+
+    @property
+    def schema_id(self):
+        return self.obj[0] if self.obj else None
+
+    @property
+    def schema(self):
+        return self.obj[1] if self.obj else None
+
+
+class AnonCredsResolutionError(BaseAnonCredsError):
+    """Raised when resolving an AnonCreds object fails."""
+
+
+class BaseAnonCredsHandler(ABC):
+    @property
+    @abstractmethod
+    def supported_identifiers_regex(self) -> Pattern:
+        """Regex to match supported identifiers."""
+
+    async def supports(self, identifier: str) -> bool:
+        """Determine whether this registry supports the given identifier."""
+        return bool(self.supported_identifiers_regex.match(identifier))
+
+    @abstractmethod
+    async def setup(self, context: InjectionContext):
+        """Setup method."""
+
+
+class BaseAnonCredsResolver(BaseAnonCredsHandler):
+    @abstractmethod
+    async def get_schema(self, profile: Profile, schema_id: str) -> GetSchemaResult:
+        """Get a schema from the registry."""
+
+    @abstractmethod
+    async def get_credential_definition(
+        self, profile: Profile, credential_definition_id: str
+    ) -> GetCredDefResult:
+        """Get a credential definition from the registry."""
+
+    @abstractmethod
+    async def get_revocation_registry_definition(
+        self, profile: Profile, revocation_registry_id: str
+    ) -> AnonCredsRegistryGetRevocationRegistryDefinition:
+        """Get a revocation registry definition from the registry."""
+
+    @abstractmethod
+    async def get_revocation_status_list(
+        self, profile: Profile, revocation_registry_id: str, timestamp: str
+    ) -> GetRevStatusListResult:
+        """Get a revocation list from the registry."""
+
+
+class BaseAnonCredsRegistrar(BaseAnonCredsHandler):
+    @abstractmethod
+    async def register_schema(
+        self,
+        profile: Profile,
+        schema: AnonCredsSchema,
+        options: Optional[dict] = None,
+    ) -> SchemaResult:
+        """Register a schema on the registry."""
+
+    @abstractmethod
+    async def register_credential_definition(
+        self,
+        profile: Profile,
+        schema: GetSchemaResult,
+        credential_definition: CredDef,
+        options: Optional[dict] = None,
+    ) -> CredDefResult:
+        """Register a credential definition on the registry."""
+
+    @abstractmethod
+    async def register_revocation_registry_definition(
+        self,
+        profile: Profile,
+        revocation_registry_definition: RevRegDef,
+        options: Optional[dict] = None,
+    ) -> RevRegDefResult:
+        """Register a revocation registry definition on the registry."""
+
+    @abstractmethod
+    async def register_revocation_status_list(
+        self,
+        profile: Profile,
+        rev_status_list: RevStatusList,
+        options: Optional[dict] = None,
+    ) -> RevStatusListResult:
+        """Register a revocation list on the registry."""

aries_cloudagent/anoncreds/default/did_indy/registry.py

@@ -0,0 +1,95 @@
+"""DID Indy Registry"""
+import logging
+import re
+from typing import Pattern
+
+from ....config.injection_context import InjectionContext
+from ....core.profile import Profile
+from ...models.anoncreds_cred_def import (
+    GetCredDefResult,
+)
+from ...models.anoncreds_revocation import (
+    GetRevStatusListResult,
+    AnonCredsRegistryGetRevocationRegistryDefinition,
+)
+from ...models.anoncreds_schema import GetSchemaResult
+from ...base import BaseAnonCredsRegistrar, BaseAnonCredsResolver
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DIDIndyRegistry(BaseAnonCredsResolver, BaseAnonCredsRegistrar):
+    """DIDIndyRegistry"""
+
+    def __init__(self):
+        self._supported_identifiers_regex = re.compile(r"^did:indy:.*$")
+
+    @property
+    def supported_identifiers_regex(self) -> Pattern:
+        return self._supported_identifiers_regex
+        # TODO: fix regex (too general)
+
+    async def setup(self, context: InjectionContext):
+        """Setup."""
+        print("Successfully registered DIDIndyRegistry")
+
+    async def get_schema(self, profile: Profile, schema_id) -> GetSchemaResult:
+        """Get a schema from the registry."""
+
+    async def get_schemas(self, profile: Profile, filter: str):
+        """Get schema ids filtered by filter"""
+
+    # TODO: determine keyword arguments
+    async def register_schema(
+        self,
+        profile: Profile,
+        options: dict,
+        schema,
+    ):
+        """Register a schema on the registry."""
+
+    async def get_credential_definition(
+        self, profile: Profile, cred_def_id: str
+    ) -> GetCredDefResult:
+        """Get a credential definition from the registry."""
+
+    async def get_credential_definitions(self, profile: Profile, filter: str):
+        """Get credential definition ids filtered by filter"""
+
+    # TODO: determine keyword arguments
+    async def register_credential_definition(
+        self,
+        profile: Profile,
+        schema_id: str,
+        support_revocation: bool,
+        tag: str,
+        rev_reg_size: int,
+        issuer_id: str,
+    ):
+        """Register a credential definition on the registry."""
+
+    async def get_revocation_registry_definition(
+        self, profile: Profile, rev_reg_id: str
+    ) -> AnonCredsRegistryGetRevocationRegistryDefinition:
+        """Get a revocation registry definition from the registry."""
+
+    # TODO: determine keyword arguments
+    async def register_revocation_registry_definition(
+        self,
+        profile: Profile,
+        rev_reg_id: str,
+        issuer_id: str,
+    ):
+        """Register a revocation registry definition on the registry."""
+
+    async def get_revocation_registry_definitions(self, profile: Profile, filter: str):
+        """Get credential definition ids filtered by filter"""
+
+    async def get_revocation_status_list(
+        self, profile: Profile, revocation_registry_id: str, timestamp: str
+    ) -> GetRevStatusListResult:
+        """Get a revocation list from the registry."""
+
+    # TODO: determine keyword arguments
+    async def register_revocation_status_list(self):
+        """Register a revocation list on the registry."""

aries_cloudagent/anoncreds/default/did_indy/routes.py

@@ -0,0 +1 @@
+"""Routes for DID Indy Registry"""