feat: Use acceptheaders in cheqdResolver for dereferencing

Signed-off-by: DaevMithran <[email protected]>

Author: DaevMithran

cheqd/cheqd/anoncreds/registry.py

@@ -133,7 +133,7 @@ async def get_schema_info_by_schema_id(
 
     async def get_schema(self, _profile: Profile, schema_id: str) -> GetSchemaResult:
         """Get a schema from the registry."""
-        resource_with_metadata = await self.resolver.resolve_resource(schema_id)
+        resource_with_metadata = await self.resolver.dereference_with_metadata(_profile, schema_id)
         schema = resource_with_metadata.resource
         metadata = resource_with_metadata.metadata
 
@@ -168,7 +168,8 @@ async def register_schema(
         try:
             # check if schema already exists
             try:
-                existing_schema = await self.resolver.resolve_resource(
+                existing_schema = await self.resolver.dereference_with_metadata(
+                    profile,
                     f"{schema.issuer_id}?resourceName={resource_name}&resourceType={resource_type}"
                 )
             except DIDNotFound:
@@ -179,7 +180,6 @@ async def register_schema(
             LOGGER.debug("Existing schema %s", existing_schema)
             # update if schema exists
             if existing_schema is not None:
-                LOGGER.debug("UPDATING SCHEMA")
                 cheqd_schema = ResourceUpdateRequestOptions(
                     options=Options(
                         name=resource_name,
@@ -255,9 +255,7 @@ async def get_credential_definition(
         self, _profile: Profile, credential_definition_id: str
     ) -> GetCredDefResult:
         """Get a credential definition from the registry."""
-        resource_with_metadata = await self.resolver.resolve_resource(
-            credential_definition_id
-        )
+        resource_with_metadata = await self.resolver.dereference_with_metadata(_profile, credential_definition_id)
         credential_definition = resource_with_metadata.resource
         metadata = resource_with_metadata.metadata
         (did, resource_id) = self.split_did_url(credential_definition_id)
@@ -334,9 +332,7 @@ async def get_revocation_registry_definition(
         self, _profile: Profile, revocation_registry_id: str
     ) -> GetRevRegDefResult:
         """Get a revocation registry definition from the registry."""
-        resource_with_metadata = await self.resolver.resolve_resource(
-            revocation_registry_id
-        )
+        resource_with_metadata = await self.resolver.dereference_with_metadata(_profile, revocation_registry_id)
         revocation_registry_definition = resource_with_metadata.resource
         metadata = resource_with_metadata.metadata
 
@@ -436,7 +432,8 @@ async def get_revocation_list(
         dt_object = datetime.fromtimestamp(epoch_time, tz=timezone.utc)
 
         resource_time = dt_object.strftime("%Y-%m-%dT%H:%M:%SZ")
-        resource_with_metadata = await self.resolver.resolve_resource(
+        resource_with_metadata = await self.resolver.dereference_with_metadata(
+            profile,
             f"{did}?resourceType={resource_type}&resourceName={resource_name}&resourceVersionTime={resource_time}"
         )
         status_list = resource_with_metadata.resource
@@ -460,7 +457,7 @@ async def get_schema_info_by_id(
         self, profile: Profile, schema_id: str
     ) -> AnoncredsSchemaInfo:
         """Get a schema info from the registry."""
-        resource_with_metadata = await self.resolver.resolve_resource(schema_id)
+        resource_with_metadata = await self.resolver.dereference_with_metadata(profile, schema_id)
         schema = resource_with_metadata.resource
         (did, resource_id) = self.split_did_url(schema_id)
         anoncreds_schema = AnoncredsSchemaInfo(

cheqd/cheqd/resolver/resolver.py

@@ -14,17 +14,31 @@
 )
 from aiohttp import ClientSession
 from pydid import DIDDocument
+from pydantic import BaseModel
 
 from ..validation import CheqdDID
 
-
 @dataclass
 class DIDLinkedResourceWithMetadata:
     """Schema for DID Linked Resource with metadata."""
 
     resource: dict
     metadata: dict
 
+class DIDUrlDereferencingResult(BaseModel):
+    """DID Url Dereferencing Result with Metadata."""
+
+    contentStream: dict
+    contentMetadata: dict
+
+    class Config:
+        """Pydantic config."""
+
+        extra = "allow"
+
+DID_RESOLUTION_HEADER = "application/ld+json;profile=https://w3id.org/did-resolution"
+DID_URL_DEREFERENCING_HEADER = "application/ld+json;profile=https://w3id.org/did-url-dereferencing"
+
 
 class CheqdDIDResolver(BaseDIDResolver):
     """DID Resolver implementation for did:cheqd."""
@@ -52,26 +66,19 @@ async def _resolve(
         service_accept: Optional[Sequence[Text]] = None,
     ) -> dict:
         """Resolve a Cheqd DID."""
+        headers = {}
+        if service_accept:
+            # Convert the Sequence[Text] to a dictionary for headers
+            headers = dict(item.split(": ", 1) for item in service_accept)
         async with ClientSession() as session:
             async with session.get(
                 self.DID_RESOLVER_BASE_URL + did,
+                headers=headers,
             ) as response:
                 if response.status == 200:
                     try:
-                        # Validate DIDDoc with pyDID
                         resolver_resp = await response.json()
-                        did_doc_resp = resolver_resp.get("didDocument")
-                        did_doc_metadata = resolver_resp.get("didDocumentMetadata")
-
-                        did_doc = DIDDocument.from_json(json.dumps(did_doc_resp))
-                        result = did_doc.serialize()
-                        # Check if 'deactivated' field is present in didDocumentMetadata
-                        if (
-                            did_doc_metadata
-                            and did_doc_metadata.get("deactivated") is True
-                        ):
-                            result["deactivated"] = True
-                        return result
+                        return resolver_resp
                     except Exception as err:
                         raise ResolverError("Response was incorrectly formatted") from err
                 if response.status == 404:
@@ -80,44 +87,34 @@ async def _resolve(
                 "Could not find doc for {}: {}".format(did, await response.text())
             )
 
-    async def resolve_resource(self, did: str) -> DIDLinkedResourceWithMetadata:
+    async def resolve(
+        self,
+        profile: Profile,
+        did: str,
+        service_accept: Optional[Sequence[Text]] = None,
+    ) -> dict:
+        resolver_resp = await self._resolve(profile, did, service_accept)
+
+        did_doc_resp = resolver_resp.get("didDocument")
+        did_doc_metadata = resolver_resp.get("didDocumentMetadata")
+
+        did_doc = DIDDocument.from_json(json.dumps(did_doc_resp))
+        result = did_doc.serialize()
+        # Check if 'deactivated' field is present in didDocumentMetadata
+        if (
+                did_doc_metadata
+                and did_doc_metadata.get("deactivated") is True
+        ):
+            result["deactivated"] = True
+        return result
+
+    async def dereference_with_metadata(self, profile: Profile, did_url: str) -> DIDLinkedResourceWithMetadata:
         """Resolve a Cheqd DID Linked Resource and its Metadata."""
-        async with ClientSession() as session:
-            # Fetch the main resource
-            async with session.get(self.DID_RESOLVER_BASE_URL + did) as response:
-                if response.status == 200:
-                    try:
-                        resource = await response.json()
-                    except Exception as err:
-                        raise ResolverError("Response was incorrectly formatted") from err
-                elif response.status == 404:
-                    raise DIDNotFound(f"No resource found for {did}")
-                else:
-                    raise ResolverError(
-                        f"Could not find resource for {did}: {await response.text()}"
-                    )
-
-            # Fetch the metadata
-            async with session.get(
-                f"{self.DID_RESOLVER_BASE_URL}{did}&resourceMetadata=true"
-                if "resourceName" in did
-                else f"{self.DID_RESOLVER_BASE_URL}{did}/metadata"
-            ) as response:
-                if response.status == 200:
-                    try:
-                        result = await response.json()
-                        metadata = result.get("contentStream").get(
-                            "linkedResourceMetadata"
-                        )[0]
-                    except Exception as err:
-                        raise ResolverError(
-                            "Metadata response was incorrectly formatted"
-                        ) from err
-                elif response.status == 404:
-                    raise DIDNotFound(f"No metadata found for {did}")
-                else:
-                    raise ResolverError(
-                        f"Could not find metadata for {did}: {await response.text()}"
-                    )
-
-        return DIDLinkedResourceWithMetadata(resource=resource, metadata=metadata)
+        # Fetch the main resource
+        result = await self._resolve(profile, did_url, [f"Accept: {DID_URL_DEREFERENCING_HEADER}"])
+
+        validated_resp = DIDUrlDereferencingResult(**result)
+        return DIDLinkedResourceWithMetadata(
+            resource=validated_resp.contentStream,
+            metadata=validated_resp.contentMetadata
+        )