tba-protocol-identity-did-core 0.4.0.dev2__tar.gz

tba_protocol_identity_did_core-0.4.0.dev2/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: tba-protocol-identity-did-core
+Version: 0.4.0.dev2
+Summary: 
+Requires-Python: >=3.10,<3.15
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: tba-concrete-did-document (==0.4.0.dev2)
+Requires-Dist: tba-contracts-identity-document (==0.4.0.dev2)

tba_protocol_identity_did_core-0.4.0.dev2/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name="tba-protocol-identity-did-core"
+version="0.4.0.dev2"
+requires-python=">=3.10,<3.15"
+dependencies=["tba-concrete-did-document==0.4.0.dev2", "tba-contracts-identity-document==0.4.0.dev2"]
+[build-system]
+requires=["poetry-core>=1.0.0"]
+build-backend="poetry.core.masonry.api"
+[tool.poetry]
+packages=[{include="tba_protocol_identity_did_core",from="src"}]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/__init__.py

@@ -0,0 +1,20 @@
+from .compatibility import require_version
+from .features import FEATURES, supports
+from .migrations import migration_path
+from .protocol import DidCoreProtocol
+from .validation import RELATIONSHIPS, validate_did, validate_document
+from .versions import CURRENT_VERSION, VERSION_HISTORY, DidCoreVersion
+
+__all__ = [
+    "DidCoreProtocol",
+    "CURRENT_VERSION",
+    "FEATURES",
+    "RELATIONSHIPS",
+    "VERSION_HISTORY",
+    "DidCoreVersion",
+    "migration_path",
+    "require_version",
+    "supports",
+    "validate_did",
+    "validate_document",
+]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/bindings.py

@@ -0,0 +1,5 @@
+"""Capability bindings owned by the versioned protocol package."""
+
+PROTOCOL_CAPABILITY_BINDINGS: tuple[str, ...] = ()
+
+__all__ = ["PROTOCOL_CAPABILITY_BINDINGS"]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/claims.py

@@ -0,0 +1,5 @@
+"""Claim vocabulary selected by the versioned protocol package."""
+
+PROTOCOL_CLAIM_NAMES: tuple[str, ...] = ()
+
+__all__ = ["PROTOCOL_CLAIM_NAMES"]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/compatibility.py

@@ -0,0 +1,3 @@
+def require_version(identifier: str) -> None:
+    if identifier != "DID-Core-1.0":
+        raise ValueError(f"unsupported DID Core revision: {identifier}")

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/errors.py

@@ -0,0 +1,8 @@
+"""Errors raised by the versioned protocol package."""
+
+
+class ProtocolProfileError(ValueError):
+    """The artifact or request does not satisfy the selected protocol profile."""
+
+
+__all__ = ["ProtocolProfileError"]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/features.py

@@ -0,0 +1,15 @@
+FEATURES = frozenset(
+    {
+        "did-syntax",
+        "did-url",
+        "verification-method",
+        "verification-relationships",
+        "services",
+        "resolution-metadata",
+        "document-metadata",
+    }
+)
+
+
+def supports(feature: str) -> bool:
+    return feature in FEATURES

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/migrations.py

@@ -0,0 +1,4 @@
+def migration_path(source: str, target: str = "DID-Core-1.0") -> tuple[str, ...]:
+    if source == target:
+        return ()
+    raise ValueError(f"no automatic DID Core migration from {source} to {target}")

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/protocol.py

@@ -0,0 +1,79 @@
+"""DID Core parsing, resolution, and verification bindings."""
+
+from tba_concrete_did_document import DidDocument
+from tba_contracts_identity_document import (
+    IdentityDocumentResolverPort,
+    IdentityDocumentVerificationRequest,
+    IdentityDocumentVerificationResult,
+)
+
+from .validation import validate_document
+
+
+class DidCoreProtocol:
+    def __init__(self, resolver: IdentityDocumentResolverPort | None = None) -> None:
+        self._resolver = resolver
+
+    def parse(
+        self,
+        representation: bytes | str,
+        *,
+        media_type: str = "application/did+json",
+    ) -> DidDocument:
+        document = DidDocument.from_representation(
+            representation,
+            media_type=media_type,
+        )
+        validate_document(document.content)
+        return document
+
+    def verify(
+        self,
+        request: IdentityDocumentVerificationRequest,
+        /,
+    ) -> IdentityDocumentVerificationResult:
+        document = request.document
+        try:
+            parsed = self.parse(
+                document.representation,
+                media_type=document.media_type,
+            )
+            if (
+                request.expected_subject is not None
+                and parsed.subject != request.expected_subject
+            ):
+                raise ValueError("DID Document subject mismatch")
+            if (
+                request.expected_controller is not None
+                and parsed.controller != request.expected_controller
+            ):
+                raise ValueError("DID Document controller mismatch")
+        except (TypeError, ValueError) as exc:
+            return IdentityDocumentVerificationResult(False, reason=str(exc))
+        return IdentityDocumentVerificationResult(
+            True,
+            structural_valid=True,
+            controller_authorized=True,
+            key_material_valid=True,
+            representation_valid=True,
+            subject=parsed.subject,
+            controller=parsed.controller,
+            evidence={"did_core_revision": "1.0"},
+        )
+
+    def resolve(self, identifier: str, /) -> DidDocument:
+        if self._resolver is None:
+            raise RuntimeError("DID resolver is not configured")
+        document = self._resolver.resolve(identifier)
+        result = self.verify(
+            IdentityDocumentVerificationRequest(
+                document,
+                expected_subject=identifier,
+            )
+        )
+        if not result.valid:
+            raise ValueError(result.reason or "resolved DID Document is invalid")
+        return self.parse(document.representation, media_type=document.media_type)
+
+
+__all__ = ["DidCoreProtocol"]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/schemas.py

@@ -0,0 +1,5 @@
+"""Wire-schema inventory owned by the versioned protocol package."""
+
+PROTOCOL_WIRE_SCHEMA_NAMES: tuple[str, ...] = ()
+
+__all__ = ["PROTOCOL_WIRE_SCHEMA_NAMES"]

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/validation.py

@@ -0,0 +1,70 @@
+from collections.abc import Mapping, Sequence
+
+RELATIONSHIPS = frozenset(
+    {
+        "authentication",
+        "assertionMethod",
+        "keyAgreement",
+        "capabilityInvocation",
+        "capabilityDelegation",
+    }
+)
+_KEY_MATERIAL_MEMBERS = frozenset({"publicKeyJwk", "publicKeyMultibase"})
+
+
+def validate_did(value: str) -> None:
+    if not value.startswith("did:") or value.count(":") < 2:
+        raise ValueError("invalid DID syntax")
+    method, method_specific_id = value[4:].split(":", 1)
+    if not method or not method_specific_id or any(ch.isspace() for ch in value):
+        raise ValueError("invalid DID syntax")
+
+
+def validate_document(document: Mapping[str, object]) -> None:
+    identifier = document.get("id")
+    if not isinstance(identifier, str):
+        raise ValueError("DID Document id is required")
+    validate_did(identifier)
+
+    controllers = document.get("controller", ())
+    if isinstance(controllers, str):
+        controllers = (controllers,)
+    if not isinstance(controllers, Sequence):
+        raise ValueError("controller must be a DID or sequence of DIDs")
+    for controller in controllers:
+        if not isinstance(controller, str):
+            raise ValueError("controller must contain DIDs")
+        validate_did(controller)
+
+    methods = document.get("verificationMethod", ())
+    if not isinstance(methods, Sequence) or isinstance(methods, (str, bytes)):
+        raise ValueError("verificationMethod must be an array")
+    known: set[str] = set()
+    for method in methods:
+        if not isinstance(method, Mapping):
+            raise ValueError("verificationMethod entries must be objects")
+        method_id = method.get("id")
+        method_controller = method.get("controller")
+        method_type = method.get("type")
+        if not all(
+            isinstance(value, str) and value
+            for value in (method_id, method_controller, method_type)
+        ):
+            raise ValueError("verificationMethod requires id, controller, and type")
+        validate_did(method_controller)
+        key_members = _KEY_MATERIAL_MEMBERS.intersection(method)
+        if len(key_members) != 1:
+            raise ValueError(
+                "verificationMethod requires exactly one public key representation"
+            )
+        known.add(method_id)
+
+    for relationship in RELATIONSHIPS:
+        entries = document.get(relationship, ())
+        if not isinstance(entries, Sequence) or isinstance(entries, (str, bytes)):
+            raise ValueError(f"{relationship} must be an array")
+        for entry in entries:
+            if isinstance(entry, str) and entry not in known:
+                raise ValueError(f"unresolved verification relationship: {entry}")
+            if not isinstance(entry, (str, Mapping)):
+                raise ValueError(f"invalid {relationship} entry")

tba_protocol_identity_did_core-0.4.0.dev2/src/tba_protocol_identity_did_core/versions.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class DidCoreVersion:
+    identifier: str
+    status: str
+    published: str
+    specification_uri: str
+
+
+CURRENT_VERSION = DidCoreVersion(
+    "DID-Core-1.0",
+    "W3C-Recommendation",
+    "2022-07-19",
+    "https://www.w3.org/TR/did-core/",
+)
+VERSION_HISTORY = (CURRENT_VERSION,)