Merge branch 'main' into redis_plugin_doc

Author: shaangill025

Endorser.md

@@ -56,7 +56,7 @@ Endorsement:
                         For Authors, specify whether to automatically create transactions for a cred def's revocation registry. (If not specified, the controller must invoke the endpoints required to create
                         the revocation registry and assign to the cred def.) [env var: ACAPY_CREATE_REVOCATION_TRANSACTIONS]
   --auto-promote-author-did
-                        For Authors, specify whether to automatically promote a DID to the wallet public DID after writing to the ledger.
+                        For Authors, specify whether to automatically promote a DID to the wallet public DID after writing to the ledger. [env var: ACAPY_AUTO_PROMOTE_AUTHOR_DID]
 ```
 
 ## How Aca-py Handles Endorsements

aries_cloudagent/config/argparse.py

@@ -1837,7 +1837,7 @@ def add_arguments(self, parser: ArgumentParser):
         parser.add_argument(
             "--auto-promote-author-did",
             action="store_true",
-            env_var="ACAPY_PROMOTE-AUTHOR-DID",
+            env_var="ACAPY_AUTO_PROMOTE_AUTHOR_DID",
             help="For Authors, specify whether to automatically promote"
             " a DID to the wallet public DID after writing to the ledger.",
         )

aries_cloudagent/config/default_context.py

@@ -1,27 +1,27 @@
 """Classes for configuring the default injection context."""
 
-from .base_context import ContextBuilder
-from .injection_context import InjectionContext
-from .provider import CachedProvider, ClassProvider
-
 from ..cache.base import BaseCache
 from ..cache.in_memory import InMemoryCache
 from ..core.event_bus import EventBus
+from ..core.goal_code_registry import GoalCodeRegistry
 from ..core.plugin_registry import PluginRegistry
 from ..core.profile import ProfileManager, ProfileManagerProvider
 from ..core.protocol_registry import ProtocolRegistry
-from ..core.goal_code_registry import GoalCodeRegistry
-from ..resolver.did_resolver import DIDResolver
-from ..tails.base import BaseTailsServer
-
 from ..protocols.actionmenu.v1_0.base_service import BaseMenuService
 from ..protocols.actionmenu.v1_0.driver_service import DriverMenuService
 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 ..resolver.did_resolver import DIDResolver
+from ..tails.base import BaseTailsServer
 from ..transport.wire_format import BaseWireFormat
-from ..utils.stats import Collector
 from ..utils.dependencies import is_indy_sdk_module_installed
+from ..utils.stats import Collector
+from ..wallet.did_method import DIDMethods
+from ..wallet.key_type import KeyTypes
+from .base_context import ContextBuilder
+from .injection_context import InjectionContext
+from .provider import CachedProvider, ClassProvider
 
 
 class DefaultContextBuilder(ContextBuilder):
@@ -51,6 +51,8 @@ async def build_context(self) -> InjectionContext:
 
         # Global did resolver
         context.injector.bind_instance(DIDResolver, DIDResolver([]))
+        context.injector.bind_instance(DIDMethods, DIDMethods())
+        context.injector.bind_instance(KeyTypes, KeyTypes())
 
         await self.bind_providers(context)
         await self.load_plugins(context)

aries_cloudagent/config/wallet.py

@@ -11,8 +11,8 @@
 from ..wallet.base import BaseWallet
 from ..wallet.crypto import seed_to_did
 from ..wallet.did_info import DIDInfo
-from ..wallet.did_method import DIDMethod
-from ..wallet.key_type import KeyType
+from ..wallet.did_method import SOV
+from ..wallet.key_type import ED25519
 from .base import ConfigError
 from .injection_context import InjectionContext
 
@@ -79,7 +79,7 @@ async def wallet_config(
         if wallet_seed and seed_to_did(wallet_seed) != public_did:
             if context.settings.get("wallet.replace_public_did"):
                 replace_did_info = await wallet.create_local_did(
-                    method=DIDMethod.SOV, key_type=KeyType.ED25519, seed=wallet_seed
+                    method=SOV, key_type=ED25519, seed=wallet_seed
                 )
                 public_did = replace_did_info.did
                 await wallet.set_public_did(public_did)
@@ -99,8 +99,8 @@ async def wallet_config(
             metadata = {"endpoint": endpoint} if endpoint else None
 
             local_did_info = await wallet.create_local_did(
-                method=DIDMethod.SOV,
-                key_type=KeyType.ED25519,
+                method=SOV,
+                key_type=ED25519,
                 seed=wallet_seed,
                 metadata=metadata,
             )
@@ -110,7 +110,7 @@ async def wallet_config(
                 print(f"Verkey: {local_did_info.verkey}")
         else:
             public_did_info = await wallet.create_public_did(
-                method=DIDMethod.SOV, key_type=KeyType.ED25519, seed=wallet_seed
+                method=SOV, key_type=ED25519, seed=wallet_seed
             )
             public_did = public_did_info.did
             if provision:
@@ -128,8 +128,8 @@ async def wallet_config(
             test_seed = "testseed000000000000000000000001"
     if test_seed:
         await wallet.create_local_did(
-            method=DIDMethod.SOV,
-            key_type=KeyType.ED25519,
+            method=SOV,
+            key_type=ED25519,
             seed=test_seed,
             metadata={"endpoint": "1.2.3.4:8021"},
         )

aries_cloudagent/connections/base_manager.py

@@ -5,7 +5,7 @@
 """
 
 import logging
-from typing import List, Sequence, Tuple
+from typing import Optional, List, Sequence, Tuple, Text
 
 from pydid import (
     BaseDIDDocument as ResolvedDocument,
@@ -227,7 +227,9 @@ async def remove_keys_for_did(self, did: str):
             storage: BaseStorage = session.inject(BaseStorage)
             await storage.delete_all_records(self.RECORD_TYPE_DID_KEY, {"did": did})
 
-    async def resolve_invitation(self, did: str):
+    async def resolve_invitation(
+        self, did: str, service_accept: Optional[Sequence[Text]] = None
+    ):
         """
         Resolve invitation with the DID Resolver.
 
@@ -241,7 +243,7 @@ async def resolve_invitation(self, did: str):
 
         resolver = self._profile.inject(DIDResolver)
         try:
-            doc_dict: dict = await resolver.resolve(self._profile, did)
+            doc_dict: dict = await resolver.resolve(self._profile, did, service_accept)
             doc: ResolvedDocument = pydid.deserialize_document(doc_dict, strict=True)
         except ResolverError as error:
             raise BaseConnectionManagerError(

aries_cloudagent/core/conductor.py

@@ -450,8 +450,7 @@ async def start(self) -> None:
                         if mediation_connections_invite
                         else OutOfBandManager(self.root_profile)
                     )
-
-                    conn_record = await mgr.receive_invitation(
+                    record = await mgr.receive_invitation(
                         invitation=invitation_handler.from_url(
                             mediation_invite_record.invite
                         ),
@@ -464,10 +463,10 @@ async def start(self) -> None:
                             ).mark_default_invite_as_used()
                         )
 
-                        await conn_record.metadata_set(
+                        await record.metadata_set(
                             session, MediationManager.SEND_REQ_AFTER_CONNECTION, True
                         )
-                        await conn_record.metadata_set(
+                        await record.metadata_set(
                             session, MediationManager.SET_TO_DEFAULT_ON_GRANTED, True
                         )
 
@@ -482,7 +481,8 @@ async def start(self) -> None:
     async def stop(self, timeout=1.0):
         """Stop the agent."""
         # notify protcols that we are shutting down
-        await self.root_profile.notify(SHUTDOWN_EVENT_TOPIC, {})
+        if self.root_profile:
+            await self.root_profile.notify(SHUTDOWN_EVENT_TOPIC, {})
 
         shutdown = TaskQueue()
         if self.dispatcher:
@@ -494,13 +494,13 @@ async def stop(self, timeout=1.0):
         if self.outbound_transport_manager:
             shutdown.run(self.outbound_transport_manager.stop())
 
-        # close multitenant profiles
-        multitenant_mgr = self.context.inject_or(BaseMultitenantManager)
-        if multitenant_mgr:
-            for profile in multitenant_mgr.open_profiles:
-                shutdown.run(profile.close())
-
         if self.root_profile:
+            # close multitenant profiles
+            multitenant_mgr = self.context.inject_or(BaseMultitenantManager)
+            if multitenant_mgr:
+                for profile in multitenant_mgr.open_profiles:
+                    shutdown.run(profile.close())
+
             shutdown.run(self.root_profile.close())
 
         await shutdown.complete(timeout)

aries_cloudagent/core/dispatcher.py

@@ -10,7 +10,7 @@
 import os
 import warnings
 
-from typing import Callable, Coroutine, Union
+from typing import Callable, Coroutine, Optional, Union, Tuple
 import weakref
 
 from aiohttp.web import HTTPException
@@ -36,6 +36,13 @@
 
 from .error import ProtocolMinorVersionNotSupported
 from .protocol_registry import ProtocolRegistry
+from .util import (
+    get_version_from_message_type,
+    validate_get_response_version,
+    # WARNING_DEGRADED_FEATURES,
+    # WARNING_VERSION_MISMATCH,
+    # WARNING_VERSION_NOT_SUPPORTED,
+)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -133,16 +140,22 @@ async def handle_message(
             inbound_message: The inbound message instance
             send_outbound: Async function to send outbound messages
 
+        # Raises:
+        #     MessageParseError: If the message type version is not supported
+
         Returns:
             The response from the handler
 
         """
         r_time = get_timer()
 
         error_result = None
+        version_warning = None
         message = None
         try:
-            message = await self.make_message(inbound_message.payload)
+            (message, warning) = await self.make_message(
+                profile, inbound_message.payload
+            )
         except ProblemReportParseError:
             pass  # avoid problem report recursion
         except MessageParseError as e:
@@ -155,6 +168,47 @@ async def handle_message(
             )
             if inbound_message.receipt.thread_id:
                 error_result.assign_thread_id(inbound_message.receipt.thread_id)
+        # if warning:
+        #     warning_message_type = inbound_message.payload.get("@type")
+        #     if warning == WARNING_DEGRADED_FEATURES:
+        #         LOGGER.error(
+        #             f"Sending {WARNING_DEGRADED_FEATURES} problem report, "
+        #             "message type received with a minor version at or higher"
+        #             " than protocol minimum supported and current minor version "
+        #             f"for message_type {warning_message_type}"
+        #         )
+        #         version_warning = ProblemReport(
+        #             description={
+        #                 "en": (
+        #                     "message type received with a minor version at or "
+        #                     "higher than protocol minimum supported and current"
+        #                     f" minor version for message_type {warning_message_type}"
+        #                 ),
+        #                 "code": WARNING_DEGRADED_FEATURES,
+        #             }
+        #         )
+        #     elif warning == WARNING_VERSION_MISMATCH:
+        #         LOGGER.error(
+        #             f"Sending {WARNING_VERSION_MISMATCH} problem report, message "
+        #             "type received with a minor version higher than current minor "
+        #             f"version for message_type {warning_message_type}"
+        #         )
+        #         version_warning = ProblemReport(
+        #             description={
+        #                 "en": (
+        #                     "message type received with a minor version higher"
+        #                     " than current minor version for message_type"
+        #                     f" {warning_message_type}"
+        #                 ),
+        #                 "code": WARNING_VERSION_MISMATCH,
+        #             }
+        #         )
+        #     elif warning == WARNING_VERSION_NOT_SUPPORTED:
+        #         raise MessageParseError(
+        #             f"Message type version not supported for {warning_message_type}"
+        #         )
+        #     if version_warning and inbound_message.receipt.thread_id:
+        #         version_warning.assign_thread_id(inbound_message.receipt.thread_id)
 
         trace_event(
             self.profile.settings,
@@ -199,6 +253,8 @@ async def handle_message(
 
         if error_result:
             await responder.send_reply(error_result)
+        elif version_warning:
+            await responder.send_reply(version_warning)
         elif context.message:
             context.injector.bind_instance(BaseResponder, responder)
 
@@ -215,7 +271,9 @@ async def handle_message(
             perf_counter=r_time,
         )
 
-    async def make_message(self, parsed_msg: dict) -> BaseMessage:
+    async def make_message(
+        self, profile: Profile, parsed_msg: dict
+    ) -> Tuple[BaseMessage, Optional[str]]:
         """
         Deserialize a message dict into the appropriate message instance.
 
@@ -224,6 +282,7 @@ async def make_message(self, parsed_msg: dict) -> BaseMessage:
 
         Args:
             parsed_msg: The parsed message
+            profile: Profile
 
         Returns:
             An instance of the corresponding message class for this message
@@ -240,6 +299,7 @@ async def make_message(self, parsed_msg: dict) -> BaseMessage:
 
         if not message_type:
             raise MessageParseError("Message does not contain '@type' parameter")
+        message_type_rec_version = get_version_from_message_type(message_type)
 
         registry: ProtocolRegistry = self.profile.inject(ProtocolRegistry)
         try:
@@ -256,8 +316,10 @@ async def make_message(self, parsed_msg: dict) -> BaseMessage:
             if "/problem-report" in message_type:
                 raise ProblemReportParseError("Error parsing problem report message")
             raise MessageParseError(f"Error deserializing message: {e}") from e
-
-        return instance
+        _, warning = await validate_get_response_version(
+            profile, message_type_rec_version, message_cls
+        )
+        return (instance, warning)
 
     async def complete(self, timeout: float = 0.1):
         """Wait for pending tasks to complete."""