The features, handlers and tests Kene has been working on

aries_cloudagent/messaging/valid.py

@@ -950,6 +950,7 @@ def __init__(
 INDY_CRED_DEF_ID_VALIDATE = IndyCredDefId()
 INDY_CRED_DEF_ID_EXAMPLE = IndyCredDefId.EXAMPLE
 
+
 INDY_REV_REG_ID_VALIDATE = IndyRevRegId()
 INDY_REV_REG_ID_EXAMPLE = IndyRevRegId.EXAMPLE
 

aries_cloudagent/protocols/issue_credential/v2_0/formats/ld_proof/models/cred_detail.py

@@ -80,3 +80,4 @@ class Meta:
             "example": {"proofType": "Ed25519Signature2018"},
         },
     )
+

aries_cloudagent/protocols/issue_credential/v2_0/formats/vc_di/models/cred_detail.py

@@ -0,0 +1,102 @@
+"""Linked data proof verifiable options detail artifacts to attach to RFC 453 messages."""
+
+from typing import Optional, Union
+
+from marshmallow import INCLUDE, fields
+
+
+from .......messaging.models.base import BaseModel, BaseModelSchema
+from .......vc.vc_ld import CredentialSchema
+from .......vc.vc_ld.models.credential import VerifiableCredential
+from .cred_detail_options import VCDIDetailOptions, VCDIDetailOptionsSchema
+
+# class LDProofVCDetail(BaseModel):
+#     """Linked data proof verifiable credential detail."""
+
+#     class Meta:
+#         """LDProofVCDetail metadata."""
+
+#         schema_class = "LDProofVCDetailSchema"
+
+#     def __init__(
+#         self,
+#         credential: Optional[Union[dict, VerifiableCredential]],
+#         options: Optional[Union[dict, LDProofVCOptions]],
+#     ) -> None:
+#         """Initialize the LDProofVCDetail instance."""
+#         self.credential = credential
+#         self.options = options
+
+#     def __eq__(self, other: object) -> bool:
+#         """Comparison between linked data vc details."""
+#         if isinstance(other, LDProofVCDetail):
+#             return self.credential == other.credential and self.options == other.options
+#         return False
+
+class VCDIDetail(BaseModel):
+    """W3C verifiable credential detail"""
+    class Meta:
+        """VCDIDetail meatdata"""
+
+        schema_class = "VCDIDetailSchema"
+
+    def __init__(
+        self,
+        credential: Optional[Union[dict, VerifiableCredential]],
+        options: Optional[Union[dict, VCDIDetailOptions]],
+    ) -> None:
+        self.credential = credential
+
+    def __eq__(self, other: object) -> bool:
+        """Comparison between W3C vc details."""
+        if isinstance(other, VCDIDetail):
+            return self.credential == other.credential and self.options == other.options
+        return False
+
+class VCDIDetailSchema(BaseModelSchema):
+    """VC_DI verifiable credential detail schema."""
+
+    class Meta:
+        """Accept parameter overload."""
+
+        unknown = INCLUDE
+        model_class = VCDIDetail
+
+    credential = fields.Nested(
+        CredentialSchema(),
+        required=True,
+        metadata={
+            "description": "Detail of the VC_DI Credential to be issued",
+            "example": {
+                "@id": "284d3996-ba85-45d9-964b-9fd5805517b6",
+                "@type": "https://didcomm.org/issue-credential/2.0/issue-credential",
+                "comment": "<some comment>",
+                "formats": [
+                    {
+                        "attach_id": "5b38af88-d36f-4f77-bb7a-2f04ab806eb8",
+                        "format": "didcomm/[email protected]"
+                    }
+                ],
+                "credentials~attach": [
+                    {
+                        "@id": "5b38af88-d36f-4f77-bb7a-2f04ab806eb8",
+                        "mime-type": "application/ld+json",
+                        "data": {
+                            "base64": "ewogICAgICAgICAgIkBjb250ZXogWwogICAgICAg...(clipped)...RNVmR0SXFXZhWXgySkJBIgAgfQogICAgICAgIH0="
+                        }
+                    }
+                ]
+            }
+        },
+    )
+
+    options = fields.Nested(
+        VCDIDetailOptionsSchema(),
+        required=True,
+        metadata={
+            "description": (
+                "Options for specifying how the linked data proof is created."
+            ),
+            "example": {"proofType": "Ed25519Signature2018"},
+        },
+    )

aries_cloudagent/protocols/issue_credential/v2_0/formats/vc_di/models/cred_detail_options.py

@@ -0,0 +1,152 @@
+"""LDProofVCDetailOptions."""
+
+from typing import Optional
+
+from marshmallow import INCLUDE, Schema, fields
+
+from .......messaging.models.base import BaseModel, BaseModelSchema
+from .......messaging.valid import (
+    INDY_ISO8601_DATETIME_EXAMPLE,
+    INDY_ISO8601_DATETIME_VALIDATE,
+    UUID4_EXAMPLE,
+)
+
+
+class VCDIDetailOptions(BaseModel):
+    """W3C verifiable credential options model."""
+
+    class Meta:
+        """VCDIDetailOptions metadata."""
+
+        schema_class = "VCDIDetailOptionsSchema"
+
+    def __init__(
+        self,
+        proof_type: Optional[str] = None,
+        proof_purpose: Optional[str] = None,
+        created: Optional[str] = None,
+        domain: Optional[str] = None,
+        challenge: Optional[str] = None,
+        credential_status: Optional[dict] = None,
+    ) -> None:
+        """Initialize the VCDIDetailOptions instance."""
+
+        self.proof_type = proof_type
+        self.proof_purpose = proof_purpose
+        self.created = created
+        self.domain = domain
+        self.challenge = challenge
+        self.credential_status = credential_status
+
+    def __eq__(self, o: object) -> bool:
+        """Check equalness."""
+        if isinstance(o, VCDIDetailOptions):
+            return (
+                self.proof_type == o.proof_type
+                and self.proof_purpose == o.proof_purpose
+                and self.created == o.created
+                and self.domain == o.domain
+                and self.challenge == o.challenge
+                and self.credential_status == o.credential_status
+            )
+
+        return False
+
+
+class CredentialStatusOptionsSchema(Schema):
+    """W3C credential status options schema."""
+
+    class Meta:
+        """Accept parameter overload."""
+
+        unknown = INCLUDE
+
+    type = fields.Str(
+        required=True,
+        metadata={
+            "description": (
+                "Credential status method type to use for the credential. Should match"
+                " status method registered in the Verifiable Credential Extension"
+                " Registry"
+            ),
+            "example": "CredentialStatusList2017",
+        },
+    )
+
+
+class VCDIDetailOptionsSchema(BaseModelSchema):
+    """W3C verifiable credential options schema."""
+
+    class Meta:
+        """Accept parameter overload."""
+
+        unknown = INCLUDE
+        model_class = VCDIDetailOptions
+
+    proof_type = fields.Str(
+        data_key="proofType",
+        required=True,
+        metadata={
+            "description": (
+                "The proof type used for the proof. Should match suites registered in"
+                " the Linked Data Cryptographic Suite Registry"
+            ),
+            "example": "Ed25519Signature2018",
+        },
+    )
+
+    proof_purpose = fields.Str(
+        data_key="proofPurpose",
+        required=False,
+        metadata={
+            "description": (
+                "The proof purpose used for the proof. Should match proof purposes"
+                " registered in the W3Cs Specification"
+            ),
+            "example": "assertionMethod",
+        },
+    )
+
+    created = fields.Str(
+        required=False,
+        validate=INDY_ISO8601_DATETIME_VALIDATE,
+        metadata={
+            "description": (
+                "The date and time of the proof (with a maximum accuracy in seconds)."
+                " Defaults to current system time"
+            ),
+            "example": INDY_ISO8601_DATETIME_EXAMPLE,
+        },
+    )
+
+    domain = fields.Str(
+        required=False,
+        metadata={
+            "description": "The intended domain of validity for the proof",
+            "example": "example.com",
+        },
+    )
+
+    challenge = fields.Str(
+        required=False,
+        metadata={
+            "description": (
+                "A challenge to include in the proof. SHOULD be provided by the"
+                " requesting party of the credential (=holder)"
+            ),
+            "example": UUID4_EXAMPLE,
+        },
+    )
+
+    credential_status = fields.Nested(
+        CredentialStatusOptionsSchema(),
+        data_key="credentialStatus",
+        required=False,
+        metadata={
+            "description": (
+                "The credential status mechanism to use for the credential. Omitting"
+                " the property indicates the issued credential will not include a"
+                " credential status"
+            )
+        },
+    )

aries_cloudagent/protocols/issue_credential/v2_0/message_types.py

@@ -22,9 +22,7 @@
 
 MESSAGE_TYPES = DIDCommPrefix.qualify_all(
     {
-        CRED_20_PROPOSAL: (
-            f"{PROTOCOL_PACKAGE}.messages.cred_proposal.V20CredProposal"
-        ),
+        CRED_20_PROPOSAL: (f"{PROTOCOL_PACKAGE}.messages.cred_proposal.V20CredProposal"),
         CRED_20_OFFER: f"{PROTOCOL_PACKAGE}.messages.cred_offer.V20CredOffer",
         CRED_20_REQUEST: f"{PROTOCOL_PACKAGE}.messages.cred_request.V20CredRequest",
         CRED_20_ISSUE: f"{PROTOCOL_PACKAGE}.messages.cred_issue.V20CredIssue",

aries_cloudagent/protocols/issue_credential/v2_0/routes.py

@@ -57,6 +57,8 @@
 from .models.cred_ex_record import V20CredExRecord, V20CredExRecordSchema
 from .models.detail.indy import V20CredExRecordIndySchema
 from .models.detail.ld_proof import V20CredExRecordLDProofSchema
+from .formats.vc_di.models.cred_detail import VCDIDetailSchema
+
 
 LOGGER = logging.getLogger(__name__)
 
@@ -172,6 +174,45 @@ class V20CredFilterIndySchema(OpenAPISchema):
         metadata={"description": "Credential issuer DID", "example": INDY_DID_EXAMPLE},
     )
 
+class V20CredFilterVCDISchema(OpenAPISchema):
+    """Indy credential filtration criteria."""
+
+    cred_def_id = fields.Str(
+        required=False,
+        validate=INDY_CRED_DEF_ID_VALIDATE,
+        metadata={
+            "description": "Credential definition identifier",
+            "example": INDY_CRED_DEF_ID_EXAMPLE,
+        },
+    )
+    schema_id = fields.Str(
+        required=False,
+        validate=INDY_SCHEMA_ID_VALIDATE,
+        metadata={
+            "description": "Schema identifier",
+            "example": INDY_SCHEMA_ID_EXAMPLE,
+        },
+    )
+    schema_issuer_did = fields.Str(
+        required=False,
+        validate=INDY_DID_VALIDATE,
+        metadata={"description": "Schema issuer DID", "example": INDY_DID_EXAMPLE},
+    )
+    schema_name = fields.Str(
+        required=False,
+        metadata={"description": "Schema name", "example": "preferences"},
+    )
+    schema_version = fields.Str(
+        required=False,
+        validate=INDY_VERSION_VALIDATE,
+        metadata={"description": "Schema version", "example": INDY_VERSION_EXAMPLE},
+    )
+    issuer_did = fields.Str(
+        required=False,
+        validate=INDY_DID_VALIDATE,
+        metadata={"description": "Credential issuer DID", "example": INDY_DID_EXAMPLE},
+    )
+
 
 class V20CredFilterVCDISchema(OpenAPISchema):
     """VCDI credential filtration criteria."""
@@ -226,6 +267,13 @@ class V20CredFilterSchema(OpenAPISchema):
         required=False,
         metadata={"description": "Credential filter for linked data proof"},
     )
+    vc_di = fields.Nested(
+        VCDIDetailSchema,
+        # V20CredFilterVCDISchema,
+        required=False,
+        metadata={"description": "Credential filter for vc_di"},
+    )
+
 
     vc_di = fields.Nested(
         V20CredFilterVCDISchema,