refactor: make services more flexible

By passing in all dependencies to each method that requires it rather
than capturing it in the instance state. This should better support more
use cases than the previous structure.

This is a backwards compatible change; the more flexible services are
wrapped by the `DIDCommMessaging` class to behave exactly the same way
as before. To use the new, more flexible services, use
`DIDCommMessagingService` class.

Signed-off-by: Daniel Bluhm <dbluhm@pm.me>

Author: dbluhm

didcomm_messaging/__init__.py

@@ -46,24 +46,9 @@ class UnpackResult:
     sender_kid: Optional[str] = None
 
 
-class DIDCommMessaging(Generic[P, S]):
+class DIDCommMessagingService(Generic[P, S]):
     """Main entrypoint for DIDComm Messaging."""
 
-    def __init__(
-        self,
-        crypto: CryptoService[P, S],
-        secrets: SecretsManager[S],
-        resolver: DIDResolver,
-        packaging: PackagingService[P, S],
-        routing: RoutingService,
-    ):
-        """Initialize the DIDComm Messaging service."""
-        self.crypto = crypto
-        self.secrets = secrets
-        self.resolver = resolver
-        self.packaging = packaging
-        self.routing = routing
-
     def service_to_target(self, service: DIDCommV2Service) -> str:
         """Convert a service to a target uri.
 
@@ -76,20 +61,49 @@ def service_to_target(self, service: DIDCommV2Service) -> str:
 
         return service_endpoint.uri
 
-    async def pack(self, message: dict, to: str, frm: Optional[str] = None, **options):
+    async def pack(
+        self,
+        crypto: CryptoService[P, S],
+        resolver: DIDResolver,
+        secrets: SecretsManager[S],
+        packaging: PackagingService[P, S],
+        routing: RoutingService,
+        message: dict,
+        to: str,
+        frm: Optional[str] = None,
+        **options,
+    ):
         """Pack a message."""
         # TODO crypto layer permits packing to multiple recipients; should we as well?
 
-        encoded_message = await self.packaging.pack(
-            json.dumps(message).encode(), [to], frm, **options
+        encoded_message = await packaging.pack(
+            crypto,
+            resolver,
+            secrets,
+            json.dumps(message).encode(),
+            [to],
+            frm,
+            **options,
         )
 
-        forward, services = await self.routing.prepare_forward(to, encoded_message)
+        forward, services = await routing.prepare_forward(
+            crypto, packaging, resolver, secrets, to, encoded_message
+        )
         return PackResult(forward, services)
 
-    async def unpack(self, encoded_message: bytes, **options) -> UnpackResult:
+    async def unpack(
+        self,
+        crypto: CryptoService[P, S],
+        resolver: DIDResolver,
+        secrets: SecretsManager[S],
+        packaging: PackagingService[P, S],
+        encoded_message: bytes,
+        **options,
+    ) -> UnpackResult:
         """Unpack a message."""
-        unpacked, metadata = await self.packaging.unpack(encoded_message, **options)
+        unpacked, metadata = await packaging.unpack(
+            crypto, resolver, secrets, encoded_message, **options
+        )
         message = json.loads(unpacked.decode())
         return UnpackResult(
             message,
@@ -98,3 +112,58 @@ async def unpack(self, encoded_message: bytes, **options) -> UnpackResult:
             recipient_kid=metadata.recip_key.kid,
             sender_kid=metadata.sender_kid,
         )
+
+
+class DIDCommMessaging(Generic[P, S]):
+    """Main entrypoint for DIDComm Messaging."""
+
+    def __init__(
+        self,
+        crypto: CryptoService[P, S],
+        secrets: SecretsManager[S],
+        resolver: DIDResolver,
+        packaging: PackagingService[P, S],
+        routing: RoutingService,
+    ):
+        """Initialize the DIDComm Messaging service."""
+        self.crypto = crypto
+        self.secrets = secrets
+        self.resolver = resolver
+        self.packaging = packaging
+        self.routing = routing
+        self.dmp = DIDCommMessagingService()
+
+    async def pack(
+        self,
+        message: dict,
+        to: str,
+        frm: Optional[str] = None,
+        **options,
+    ) -> PackResult:
+        """Pack a message."""
+        return await self.dmp.pack(
+            self.crypto,
+            self.resolver,
+            self.secrets,
+            self.packaging,
+            self.routing,
+            message,
+            to,
+            frm,
+            **options,
+        )
+
+    async def unpack(
+        self,
+        encoded_message: bytes,
+        **options,
+    ) -> UnpackResult:
+        """Unpack a message."""
+        return await self.dmp.unpack(
+            self.crypto,
+            self.resolver,
+            self.secrets,
+            self.packaging,
+            encoded_message,
+            **options,
+        )

didcomm_messaging/packaging.py

@@ -28,19 +28,8 @@ class PackagingServiceError(Exception):
 class PackagingService(Generic[P, S]):
     """DIDComm Messaging interface."""
 
-    def __init__(
-        self,
-        resolver: DIDResolver,
-        crypto: CryptoService[P, S],
-        secrets: SecretsManager[S],
-    ):
-        """Initialize the KMS."""
-        self.resolver = resolver
-        self.crypto = crypto
-        self.secrets = secrets
-
     async def extract_packed_message_metadata(  # noqa: C901
-        self, enc_message: Union[str, bytes]
+        self, enc_message: Union[str, bytes], secrets: SecretsManager[S]
     ) -> PackedMessageMetadata:
         """Extract metadata from a packed DIDComm message."""
         try:
@@ -61,7 +50,7 @@ async def extract_packed_message_metadata(  # noqa: C901
         sender_kid = None
         recip_key = None
         for kid in wrapper.recipient_key_ids:
-            recip_key = await self.secrets.get_secret_by_kid(kid)
+            recip_key = await secrets.get_secret_by_kid(kid)
             if recip_key:
                 break
 
@@ -97,40 +86,42 @@ async def extract_packed_message_metadata(  # noqa: C901
         return PackedMessageMetadata(wrapper, method, recip_key, sender_kid)
 
     async def unpack(
-        self, enc_message: Union[str, bytes]
+        self,
+        crypto: CryptoService[P, S],
+        resolver: DIDResolver,
+        secrets: SecretsManager[S],
+        enc_message: Union[str, bytes],
     ) -> Tuple[bytes, PackedMessageMetadata]:
         """Unpack a DIDComm message."""
-        metadata = await self.extract_packed_message_metadata(enc_message)
+        metadata = await self.extract_packed_message_metadata(enc_message, secrets)
 
         if metadata.method == "ECDH-ES":
             return (
-                await self.crypto.ecdh_es_decrypt(enc_message, metadata.recip_key),
+                await crypto.ecdh_es_decrypt(enc_message, metadata.recip_key),
                 metadata,
             )
 
         if not metadata.sender_kid:
             raise PackagingServiceError("Missing sender key ID")
 
-        sender_vm = await self.resolver.resolve_and_dereference_verification_method(
+        sender_vm = await resolver.resolve_and_dereference_verification_method(
             metadata.sender_kid
         )
-        sender_key = self.crypto.verification_method_to_public_key(sender_vm)
+        sender_key = crypto.verification_method_to_public_key(sender_vm)
 
         return (
-            await self.crypto.ecdh_1pu_decrypt(
-                enc_message, metadata.recip_key, sender_key
-            ),
+            await crypto.ecdh_1pu_decrypt(enc_message, metadata.recip_key, sender_key),
             metadata,
         )
 
-    async def recip_for_kid_or_default_for_did(self, kid_or_did: str) -> P:
+    async def recip_for_kid_or_default_for_did(
+        self, crypto: CryptoService[P, S], resolver: DIDResolver, kid_or_did: str
+    ) -> P:
         """Resolve a verification method for a kid or return default recip."""
         if "#" in kid_or_did:
-            vm = await self.resolver.resolve_and_dereference_verification_method(
-                kid_or_did
-            )
+            vm = await resolver.resolve_and_dereference_verification_method(kid_or_did)
         else:
-            doc = await self.resolver.resolve_and_parse(kid_or_did)
+            doc = await resolver.resolve_and_parse(kid_or_did)
             if not doc.key_agreement:
                 raise PackagingServiceError(
                     "No key agreement methods found; cannot determine recipient"
@@ -146,14 +137,14 @@ async def recip_for_kid_or_default_for_did(self, kid_or_did: str) -> P:
             else:
                 vm = default
 
-        return self.crypto.verification_method_to_public_key(vm)
+        return crypto.verification_method_to_public_key(vm)
 
-    async def default_sender_kid_for_did(self, did: str) -> str:
+    async def default_sender_kid_for_did(self, resolver: DIDResolver, did: str) -> str:
         """Determine the kid of the default sender key for a DID."""
         if "#" in did:
             return did
 
-        doc = await self.resolver.resolve_and_parse(did)
+        doc = await resolver.resolve_and_parse(did)
         if not doc.key_agreement:
             raise PackagingServiceError(
                 "No key agreement methods found; cannot determine recipient"
@@ -175,21 +166,27 @@ async def default_sender_kid_for_did(self, did: str) -> str:
 
     async def pack(
         self,
+        crypto: CryptoService[P, S],
+        resolver: DIDResolver,
+        secrets: SecretsManager[S],
         message: bytes,
         to: Sequence[str],
         frm: Optional[str] = None,
         **options,
     ):
         """Pack a DIDComm message."""
-        recip_keys = [await self.recip_for_kid_or_default_for_did(kid) for kid in to]
-        sender_kid = await self.default_sender_kid_for_did(frm) if frm else None
-        sender_key = (
-            await self.secrets.get_secret_by_kid(sender_kid) if sender_kid else None
+        recip_keys = [
+            await self.recip_for_kid_or_default_for_did(crypto, resolver, kid)
+            for kid in to
+        ]
+        sender_kid = (
+            await self.default_sender_kid_for_did(resolver, frm) if frm else None
         )
+        sender_key = await secrets.get_secret_by_kid(sender_kid) if sender_kid else None
         if frm and not sender_key:
             raise PackagingServiceError("No sender key found")
 
         if sender_key:
-            return await self.crypto.ecdh_1pu_encrypt(recip_keys, sender_key, message)
+            return await crypto.ecdh_1pu_encrypt(recip_keys, sender_key, message)
         else:
-            return await self.crypto.ecdh_es_encrypt(recip_keys, message)
+            return await crypto.ecdh_es_encrypt(recip_keys, message)