✨ Create Cheqd DIDs (#1548)

* ⬆️ Upgrade CloudController

* ⬆️ Update lock file

* 🎨 Deduplicate supported methods

* ✨ Allow creation of cheqd did's

* 🐛 Fix reading options from DIDCreate

* ⬆️ Update lock file

* 🎨 Use correct model for acapy call

* 🧪 Fix test_create_did

* ✅ Test coverage for creating a cheqd did

* 📝 Update OpenAPI Specs

* 🎨

Author: ff137

app/models/wallet.py

@@ -36,12 +36,15 @@ class DIDCreate(BaseModel):
     # Downstream processes should use the `to_acapy_options` method to convert the model's fields
     # into the `DIDCreateOptions` structure expected by ACA-Py.
 
+    _supported_methods = ["cheqd", "sov", "key", "web", "did:peer:2", "did:peer:4"]
+
     method: Optional[StrictStr] = Field(
         default="sov",
         description=(
-            "Method for the requested DID. Supported methods are 'sov', 'key', 'web', 'did:peer:2', or 'did:peer:4'."
+            "Method for the requested DID. Supported methods are "
+            f"{', '.join(_supported_methods)}."
         ),
-        examples=["sov", "key", "web", "did:peer:2", "did:peer:4"],
+        examples=_supported_methods,
     )
     seed: Optional[StrictStr] = Field(
         default=None,

app/routes/wallet/dids.py

@@ -49,13 +49,10 @@ async def create_did(
     if not did_create:
         did_create = DIDCreate()
 
-    # Convert our custom DIDCreate model to ACA-Py's DIDCreate model
-    acapy_did_create_request = did_create.to_acapy_request()
-
     async with client_from_auth(auth) as aries_controller:
-        logger.debug("Creating DID with request: {}", acapy_did_create_request)
+        logger.debug("Creating DID with request: {}", did_create)
         result = await acapy_wallet.create_did(
-            controller=aries_controller, did_create=acapy_did_create_request
+            controller=aries_controller, did_create=did_create
         )
 
     logger.debug("Successfully created DID.")

app/services/acapy_wallet.py

@@ -1,8 +1,9 @@
 from typing import Optional
 
-from aries_cloudcontroller import DID, AcaPyClient, DIDCreate
+from aries_cloudcontroller import DID, AcaPyClient, CreateCheqdDIDRequest
 
 from app.exceptions import CloudApiException, handle_acapy_call
+from app.models.wallet import DIDCreate
 from app.util.did import qualified_did_sov
 from shared.log_config import get_logger
 
@@ -51,16 +52,52 @@ async def create_did(
     if did_create is None:
         did_create = DIDCreate()
 
-    did_response = await handle_acapy_call(
-        logger=logger, acapy_call=controller.wallet.create_did, body=did_create
-    )
-
-    result = did_response.result
-    if not result or not result.did or not result.verkey:
-        logger.error("Failed to create DID: `{}`.", did_response)
-        raise CloudApiException("Error creating did.")
-
-    logger.debug("Successfully created local DID.")
+    did_method = did_create.method
+
+    if did_method == "cheqd":
+        create_cheqd_did_options = did_create.to_acapy_options().to_dict()
+        if did_create.seed:
+            create_cheqd_did_options["seed"] = did_create.seed
+        # Notes:
+        # - supported options: seed, network, verification_method
+        # - key_type option is not implemented (default is ed25519)
+
+        request = CreateCheqdDIDRequest(options=create_cheqd_did_options)
+        logger.debug("Creating cheqd DID: `{}`", request)
+        cheqd_did_response = await handle_acapy_call(
+            logger=logger,
+            acapy_call=controller.did.did_cheqd_create_post,
+            body=request,
+        )
+        verkey = cheqd_did_response.verkey
+        did = cheqd_did_response.did
+
+        # Note: neither `success` nor `did_state` is populated in the response
+
+        if not verkey or not did:
+            logger.error("Failed to create cheqd DID: `{}`.", cheqd_did_response)
+            raise CloudApiException("Error creating cheqd did.")
+
+        result = DID(
+            did=did,
+            method=did_method,
+            verkey=verkey,
+            key_type="ed25519",
+            posture="posted",
+        )
+    else:
+        did_response = await handle_acapy_call(
+            logger=logger,
+            acapy_call=controller.wallet.create_did,
+            body=did_create.to_acapy_request(),
+        )
+
+        result = did_response.result
+        if not result or not result.did or not result.verkey:
+            logger.error("Failed to create DID: `{}`.", did_response)
+            raise CloudApiException("Error creating did.")
+
+    logger.debug("Successfully created local {} DID.", did_method)
     return result
 
 

app/tests/e2e/test_did_rotate.py

@@ -42,9 +42,8 @@ async def test_rotate_did(
 
     # Create a new did for Alice and rotate
     did_create_request = DIDCreate(method=did_method)
-    acapy_did_create_request = did_create_request.to_acapy_request()
     new_did = await acapy_wallet.create_did(
-        controller=alice_acapy_client, did_create=acapy_did_create_request
+        controller=alice_acapy_client, did_create=did_create_request
     )
     alice_new_did = new_did.did
 

app/tests/routes/wallet/dids/test_create_did.py

@@ -1,3 +1,4 @@
+from unittest import mock
 from unittest.mock import AsyncMock, patch
 
 import pytest
@@ -94,22 +95,24 @@
 )
 async def test_create_did_success(request_body, create_body):
     mock_aries_controller = AsyncMock()
-    mock_create_did = AsyncMock()
+    mock_aries_controller.wallet.create_did = AsyncMock()
 
     with patch(
         "app.routes.wallet.dids.client_from_auth"
     ) as mock_client_from_auth, patch(
-        "app.services.acapy_wallet.create_did", mock_create_did
-    ):
+        "app.services.acapy_wallet.handle_acapy_call"
+    ) as mock_handle_acapy_call:
         # Configure client_from_auth to return our mocked aries_controller on enter
         mock_client_from_auth.return_value.__aenter__.return_value = (
             mock_aries_controller
         )
 
         await create_did(did_create=request_body, auth="mocked_auth")
 
-        mock_create_did.assert_awaited_once_with(
-            did_create=create_body, controller=mock_aries_controller
+        mock_handle_acapy_call.assert_awaited_once_with(
+            logger=mock.ANY,
+            acapy_call=mock_aries_controller.wallet.create_did,
+            body=create_body,
         )
 
 

app/tests/services/test_acapy_wallet.py

@@ -1,7 +1,14 @@
 import pytest
-from aries_cloudcontroller import DID, AcaPyClient, DIDResult
+from aries_cloudcontroller import (
+    DID,
+    AcaPyClient,
+    CreateCheqdDIDRequest,
+    CreateCheqdDIDResponse,
+    DIDResult,
+)
 
 from app.exceptions import CloudApiException
+from app.models.wallet import DIDCreate
 from app.services import acapy_wallet
 
 
@@ -44,3 +51,98 @@ async def test_error_on_assign_pub_did(mock_agent_controller: AcaPyClient):
         await acapy_wallet.set_public_did(mock_agent_controller, did="did")
     assert exc.value.status_code == 400
     assert "Error setting public did" in exc.value.detail
+
+
+@pytest.mark.anyio
+async def test_create_cheqd_did_success(mock_agent_controller: AcaPyClient):
+    did_create_request = DIDCreate(
+        method="cheqd",
+        seed="testseed000000000000000000000001",
+    )
+
+    expected_did = "did:cheqd:testnet:abcdef1234567890"
+    expected_verkey = "WgWxqztrNooG92RXvxSTWvWgWxqztrNooG92RXvxSTWv"
+
+    mock_agent_controller.did.did_cheqd_create_post.return_value = (
+        CreateCheqdDIDResponse(
+            did=expected_did,
+            verkey=expected_verkey,
+        )
+    )
+
+    created_did = await acapy_wallet.create_did(
+        mock_agent_controller, did_create=did_create_request
+    )
+
+    assert created_did.did == expected_did
+    assert created_did.verkey == expected_verkey
+    assert created_did.method == "cheqd"
+    assert created_did.key_type == "ed25519"  # Default key_type for cheqd
+    assert created_did.posture == "posted"  # Default posture for cheqd
+
+    mock_agent_controller.did.did_cheqd_create_post.assert_called_once()
+    call_args = mock_agent_controller.did.did_cheqd_create_post.call_args
+    assert call_args is not None
+    assert isinstance(call_args.kwargs["body"], CreateCheqdDIDRequest)
+    assert (
+        call_args.kwargs["body"].options["seed"] == "testseed000000000000000000000001"
+    )
+
+
+@pytest.mark.anyio
+async def test_create_cheqd_did_success_no_seed(mock_agent_controller: AcaPyClient):
+    did_create_request = DIDCreate(method="cheqd")
+
+    expected_did = "did:cheqd:testnet:zxywv987654321"
+    expected_verkey = "HkPgtEv9hrGjGkVSkL4sT8HkPgtEv9hrGjGkVSkL4sT8"
+
+    mock_agent_controller.did.did_cheqd_create_post.return_value = (
+        CreateCheqdDIDResponse(
+            did=expected_did,
+            verkey=expected_verkey,
+        )
+    )
+
+    created_did = await acapy_wallet.create_did(
+        mock_agent_controller, did_create=did_create_request
+    )
+
+    assert created_did.did == expected_did
+    assert created_did.verkey == expected_verkey
+    assert created_did.method == "cheqd"
+
+    mock_agent_controller.did.did_cheqd_create_post.assert_called_once()
+    call_args = mock_agent_controller.did.did_cheqd_create_post.call_args
+    assert call_args is not None
+    assert isinstance(call_args.kwargs["body"], CreateCheqdDIDRequest)
+    assert (
+        "seed" not in call_args.kwargs["body"].options
+    )  # Ensure seed is not passed if not provided
+
+
+@pytest.mark.anyio
+async def test_create_cheqd_did_fail_missing_did(mock_agent_controller: AcaPyClient):
+    did_create_request = DIDCreate(method="cheqd", options={"network": "testnet"})
+
+    mock_agent_controller.did.did_cheqd_create_post.return_value = (
+        CreateCheqdDIDResponse(verkey="some_verkey")  # Missing did
+    )
+
+    with pytest.raises(CloudApiException, match="Error creating cheqd did."):
+        await acapy_wallet.create_did(
+            mock_agent_controller, did_create=did_create_request
+        )
+
+
+@pytest.mark.anyio
+async def test_create_cheqd_did_fail_missing_verkey(mock_agent_controller: AcaPyClient):
+    did_create_request = DIDCreate(method="cheqd", options={"network": "testnet"})
+
+    mock_agent_controller.did.did_cheqd_create_post.return_value = (
+        CreateCheqdDIDResponse(did="some_did")  # Missing verkey
+    )
+
+    with pytest.raises(CloudApiException, match="Error creating cheqd did."):
+        await acapy_wallet.create_did(
+            mock_agent_controller, did_create=did_create_request
+        )

docs/openapi/tenant-openapi.json

@@ -6204,9 +6204,10 @@
               }
             ],
             "title": "Method",
-            "description": "Method for the requested DID. Supported methods are 'sov', 'key', 'web', 'did:peer:2', or 'did:peer:4'.",
+            "description": "Method for the requested DID. Supported methods are cheqd, sov, key, web, did:peer:2, did:peer:4.",
             "default": "sov",
             "examples": [
+              "cheqd",
               "sov",
               "key",
               "web",

docs/openapi/tenant-openapi.yaml

@@ -3626,9 +3626,10 @@ components:
             - type: string
             - type: 'null'
           title: Method
-          description: Method for the requested DID. Supported methods are 'sov', 'key', 'web', 'did:peer:2', or 'did:peer:4'.
+          description: Method for the requested DID. Supported methods are cheqd, sov, key, web, did:peer:2, did:peer:4.
           default: sov
           examples:
+            - cheqd
             - sov
             - key
             - web