refactor: rename to V1

DIDComm v1 isn't quite legacy yet

Signed-off-by: Daniel Bluhm <[email protected]>

Author: dbluhm

didcomm_messaging/legacy/__init__.py

@@ -1,4 +1,4 @@
-"""Legacy DIDComm v1 Interfaces.
+"""V1 DIDComm v1 Interfaces.
 
 These components are intended to provide a similar structure to the DIDComm v2
 interfaces provided by this library. While the community is transitioning from

didcomm_messaging/legacy/askar.py

@@ -1,4 +1,4 @@
-"""LegacyCryptoService implementation for askar."""
+"""V1CryptoService implementation for askar."""
 
 from collections import OrderedDict
 from typing import Optional, Sequence, Tuple, cast
@@ -8,8 +8,8 @@
 
 from didcomm_messaging.crypto.jwe import JweBuilder, JweEnvelope, JweRecipient
 from didcomm_messaging.legacy.base import (
-    LegacyCryptoService,
-    LegacyUnpackResult,
+    V1CryptoService,
+    V1UnpackResult,
     RecipData,
 )
 
@@ -18,11 +18,11 @@
     from aries_askar.bindings import key_get_secret_bytes
     from didcomm_messaging.crypto.backend.askar import AskarKey, AskarSecretKey
 except ImportError:
-    raise ImportError("Legacy Askar backend requires the 'askar' extra to be installed")
+    raise ImportError("V1 Askar backend requires the 'askar' extra to be installed")
 
 
-class AskarLegacyCryptoService(LegacyCryptoService[AskarKey, AskarSecretKey]):
-    """Legacy crypto service implementation for askar."""
+class AskarV1CryptoService(V1CryptoService[AskarKey, AskarSecretKey]):
+    """V1 crypto service implementation for askar."""
 
     def kid_to_public_key(self, kid: str) -> AskarKey:
         """Get a public key from a kid.
@@ -97,7 +97,7 @@ async def unpack_message(
         wrapper: JweEnvelope,
         recip_key: AskarSecretKey,
         recip_data: RecipData,
-    ) -> LegacyUnpackResult:
+    ) -> V1UnpackResult:
         """Decode a message using the DIDComm v1 'unpack' algorithm."""
         payload_key, sender_vk = self._extract_payload_key(recip_key.key, recip_data)
 
@@ -108,7 +108,7 @@ async def unpack_message(
             tag=wrapper.tag,
             aad=wrapper.protected_b64,
         )
-        return LegacyUnpackResult(message, recip_key.kid, sender_vk)
+        return V1UnpackResult(message, recip_key.kid, sender_vk)
 
     def _extract_payload_key(
         self, recip_key: Key, recip_data: RecipData

didcomm_messaging/legacy/base.py

@@ -18,15 +18,15 @@ class RecipData(NamedTuple):
     enc_cek: bytes
 
 
-class LegacyUnpackResult(NamedTuple):
+class V1UnpackResult(NamedTuple):
     """Result of unpacking."""
 
     message: bytes
     recip: str
     sender: Optional[str]
 
 
-class LegacyCryptoService(ABC, Generic[P, S]):
+class V1CryptoService(ABC, Generic[P, S]):
     """CryptoService interface for DIDComm v1."""
 
     b64url = Base64UrlEncoder()
@@ -52,5 +52,5 @@ async def pack_message(
     @abstractmethod
     async def unpack_message(
         self, wrapper: JweEnvelope, recip_key: S, recip_data: RecipData
-    ) -> LegacyUnpackResult:
+    ) -> V1UnpackResult:
         """Decode a message using DIDCvomm v1 'unpack' algorithm."""

didcomm_messaging/legacy/crypto.py

@@ -1,7 +1,7 @@
 """DIDComm v1 packing and unpacking.
 
 This implementation is kept around for backwards compatibility. It is
-likely that you should use the LegacyCryptoService interfaces instead.
+likely that you should use the V1CryptoService interfaces instead.
 """
 
 from collections import OrderedDict
@@ -19,7 +19,7 @@
     import nacl.utils
 except ImportError as err:
     raise ImportError(
-        "Legacy implementation requires 'legacy' extra to be installed"
+        "V1 implementation requires 'legacy' extra to be installed"
     ) from err
 
 from didcomm_messaging.multiformats.multibase import Base64UrlEncoder

didcomm_messaging/legacy/messaging.py

@@ -1,4 +1,4 @@
-"""Legacy messaging service."""
+"""V1 messaging service."""
 
 from dataclasses import dataclass
 import json
@@ -10,25 +10,25 @@
 from pydid.service import DIDCommV1Service
 
 from didcomm_messaging.crypto import P, S, SecretsManager
-from didcomm_messaging.legacy.base import LegacyCryptoService
-from didcomm_messaging.legacy.packaging import LegacyPackagingService
+from didcomm_messaging.legacy.base import V1CryptoService
+from didcomm_messaging.legacy.packaging import V1PackagingService
 from didcomm_messaging.resolver import DIDResolver
 
 
-class LegacyDIDCommMessagingError(Exception):
+class V1DIDCommMessagingError(Exception):
     """Raised on error in legacy didcomm messaging."""
 
 
 @dataclass
-class LegacyPackResult:
+class V1PackResult:
     """Result of packing a message."""
 
     message: bytes
     target_service: str
 
 
 @dataclass
-class LegacyUnpackResult:
+class V1UnpackResult:
     """Result of unpacking a message."""
 
     unpacked: bytes
@@ -55,11 +55,11 @@ class Target:
     endpoint: str
 
 
-class LegacyDIDCommMessagingService(Generic[P, S]):
+class V1DIDCommMessagingService(Generic[P, S]):
     """Main entrypoint for DIDComm Messaging."""
 
     async def did_to_target(
-        self, crypto: LegacyCryptoService[P, S], resolver: DIDResolver, did: str
+        self, crypto: V1CryptoService[P, S], resolver: DIDResolver, did: str
     ) -> Target:
         """Resolve recipient information from a DID."""
         doc = await resolver.resolve_and_parse(did)
@@ -69,7 +69,7 @@ async def did_to_target(
             if isinstance(service, DIDCommV1Service)
         ]
         if not services:
-            raise LegacyDIDCommMessagingError(f"Unable to send message to DID {did}")
+            raise V1DIDCommMessagingError(f"Unable to send message to DID {did}")
         target = services[0]
 
         recipient_keys = [
@@ -92,14 +92,14 @@ async def did_to_target(
         if isinstance(endpoint, AnyUrl):
             endpoint = str(endpoint)
         if not endpoint.startswith("http") and not endpoint.startswith("ws"):
-            raise LegacyDIDCommMessagingError(
+            raise V1DIDCommMessagingError(
                 f"Unable to send message to endpoint {endpoint}"
             )
 
         return Target(recipient_keys, routing_keys, endpoint)
 
     async def from_did_to_kid(
-        self, crypto: LegacyCryptoService[P, S], resolver: DIDResolver, did: str
+        self, crypto: V1CryptoService[P, S], resolver: DIDResolver, did: str
     ) -> str:
         """Resolve our DID to a kid to be used by crypto layers."""
         doc = await resolver.resolve_and_parse(did)
@@ -109,7 +109,7 @@ async def from_did_to_kid(
             if isinstance(service, DIDCommV1Service)
         ]
         if not services:
-            raise LegacyDIDCommMessagingError(f"Unable to send message to DID {did}")
+            raise V1DIDCommMessagingError(f"Unable to send message to DID {did}")
         target = services[0]
 
         recipient_keys = [
@@ -133,10 +133,10 @@ def forward_wrap(self, to: str, msg: str) -> bytes:
 
     async def pack(
         self,
-        crypto: LegacyCryptoService[P, S],
+        crypto: V1CryptoService[P, S],
         resolver: DIDResolver,
         secrets: SecretsManager[S],
-        packaging: LegacyPackagingService[P, S],
+        packaging: V1PackagingService[P, S],
         message: Union[dict, str, bytes],
         to: Union[str, Target],
         frm: Optional[str] = None,
@@ -197,19 +197,19 @@ async def pack(
                 )
                 forward_to = routing_key
 
-        return LegacyPackResult(encoded_message.to_json().encode(), target.endpoint)
+        return V1PackResult(encoded_message.to_json().encode(), target.endpoint)
 
     async def unpack(
         self,
-        crypto: LegacyCryptoService[P, S],
+        crypto: V1CryptoService[P, S],
         secrets: SecretsManager[S],
-        packaging: LegacyPackagingService[P, S],
+        packaging: V1PackagingService[P, S],
         encoded_message: bytes,
         **options,
-    ) -> LegacyUnpackResult:
+    ) -> V1UnpackResult:
         """Unpack a message."""
         unpacked, recip, sender = await packaging.unpack(crypto, secrets, encoded_message)
-        return LegacyUnpackResult(
+        return V1UnpackResult(
             unpacked,
             encrytped=bool(recip),
             authenticated=bool(sender),
@@ -218,30 +218,30 @@ async def unpack(
         )
 
 
-class LegacyDIDCommMessaging(Generic[P, S]):
+class V1DIDCommMessaging(Generic[P, S]):
     """Main entrypoint for DIDComm Messaging."""
 
     def __init__(
         self,
-        crypto: LegacyCryptoService[P, S],
+        crypto: V1CryptoService[P, S],
         secrets: SecretsManager[S],
         resolver: DIDResolver,
-        packaging: LegacyPackagingService[P, S],
+        packaging: V1PackagingService[P, S],
     ):
         """Initialize the DIDComm Messaging service."""
         self.crypto = crypto
         self.secrets = secrets
         self.resolver = resolver
         self.packaging = packaging
-        self.dmp = LegacyDIDCommMessagingService()
+        self.dmp = V1DIDCommMessagingService()
 
     async def pack(
         self,
         message: Union[dict, str, bytes],
         to: Union[str, Target],
         frm: Optional[str] = None,
         **options,
-    ) -> LegacyPackResult:
+    ) -> V1PackResult:
         """Pack a message.
 
         Args:
@@ -252,7 +252,7 @@ async def pack(
             options: arbitrary values to pass to the packaging service
 
         Returns:
-            LegacyPackResult with packed message and target services
+            V1PackResult with packed message and target services
         """
         return await self.dmp.pack(
             self.crypto,
@@ -269,7 +269,7 @@ async def unpack(
         self,
         encoded_message: bytes,
         **options,
-    ) -> LegacyUnpackResult:
+    ) -> V1UnpackResult:
         """Unpack a message."""
         return await self.dmp.unpack(
             self.crypto,

didcomm_messaging/legacy/nacl.py

@@ -1,4 +1,4 @@
-"""LegacyCryptoService implementation for pynacl."""
+"""V1CryptoService implementation for pynacl."""
 
 from dataclasses import dataclass
 from typing import Dict, Optional, OrderedDict, Sequence, Tuple
@@ -10,15 +10,15 @@
 from didcomm_messaging.crypto.jwe import JweBuilder, JweEnvelope, JweRecipient
 from didcomm_messaging.multiformats import multibase, multicodec
 
-from .base import LegacyCryptoService, LegacyUnpackResult, RecipData
+from .base import V1CryptoService, V1UnpackResult, RecipData
 
 try:
     import nacl.bindings
     import nacl.exceptions
     import nacl.utils
 except ImportError as err:
     raise ImportError(
-        "Legacy implementation requires 'legacy' extra to be installed"
+        "V1 implementation requires 'legacy' extra to be installed"
     ) from err
 
 
@@ -75,8 +75,8 @@ def key_bytes(self) -> bytes:
         return self.value
 
 
-class NaclLegacyCryptoService(LegacyCryptoService[EdPublicKey, KeyPair]):
-    """Legacy crypto service using pynacl."""
+class NaclV1CryptoService(V1CryptoService[EdPublicKey, KeyPair]):
+    """V1 crypto service using pynacl."""
 
     def kid_to_public_key(self, kid: str):
         """Get a public key from a kid.
@@ -180,15 +180,15 @@ def _extract_payload_key(self, recip_key: KeyPair, recip_data: RecipData):
 
     async def unpack_message(
         self, wrapper: JweEnvelope, recip_key: KeyPair, recip_data: RecipData
-    ) -> LegacyUnpackResult:
+    ) -> V1UnpackResult:
         """Decode a message using DIDCvomm v1 'unpack' algorithm."""
         cek, sender_vk = self._extract_payload_key(recip_key, recip_data)
 
         payload_bin = wrapper.ciphertext + wrapper.tag
         message = nacl.bindings.crypto_aead_chacha20poly1305_ietf_decrypt(
             payload_bin, wrapper.protected_b64, wrapper.iv, cek
         )
-        return LegacyUnpackResult(message, recip_key.kid, sender_vk)
+        return V1UnpackResult(message, recip_key.kid, sender_vk)
 
 
 class InMemSecretsManager(SecretsManager[KeyPair]):