⬆️ ✨ Upgrade acapy 1.0.0

.pre-commit-config.yaml

@@ -20,4 +20,4 @@ repos:
       hooks:
           - id: isort
             stages: [push]
-            args: ["--profile", "black"]
+            args: ["--profile", "black", "."]

app/models/issuer.py

@@ -1,8 +1,12 @@
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
-from aries_cloudcontroller import LDProofVCDetail
-from pydantic import BaseModel, Field, ValidationInfo, field_validator
+from aries_cloudcontroller import (
+    LDProofVCDetail,
+    TransactionRecord,
+    TxnOrPublishRevocationsResult,
+)
+from pydantic import BaseModel, Field, ValidationInfo, field_validator, model_validator
 
 from shared.exceptions import CloudApiValueError
 from shared.models.protocol import IssueCredentialProtocolVersion
@@ -98,3 +102,39 @@ class ClearPendingRevocationsResult(BaseModel):
             "The resulting revocations that are still pending after a clear-pending request has been completed."
         ),
     )
+
+
+class RevokedResponse(BaseModel):
+    cred_rev_ids_published: Dict[str, List[int]] = Field(
+        default_factory=dict,
+        description=(
+            "A map of revocation registry IDs to lists of credential revocation IDs "
+            "(as integers) that have been revoked. Can be empty."
+        ),
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def extract_revoked_info(
+        cls, values: TxnOrPublishRevocationsResult
+    ) -> Dict[str, Any]:
+        if isinstance(values, dict) and "txn" in values:
+            txn_list: List[TransactionRecord] = values.get("txn")
+            cred_rev_ids_published = {}
+
+            for txn in txn_list:
+                for attach in txn.get("messages_attach", []):
+                    data = attach.get("data", {}).get("json", {})
+                    operation = data.get("operation", {})
+                    revoc_reg_def_id = operation.get("revocRegDefId")
+                    revoked = operation.get("value", {}).get("revoked", [])
+                    if revoc_reg_def_id and revoked:
+                        cred_rev_ids_published[revoc_reg_def_id] = revoked
+
+            values["cred_rev_ids_published"] = cred_rev_ids_published
+
+        return values
+
+
+class PendingRevocations(BaseModel):
+    pending_cred_rev_ids: list[Optional[int]] = []

app/pyproject.toml

@@ -9,7 +9,7 @@ package-mode = false
 python = "^3.12"
 
 aiohttp = "~3.10.3"
-aries-cloudcontroller = "==1.0.0rc4"
+aries-cloudcontroller = "==1.0.0"
 base58 = "~2.1.1"
 fastapi = "~0.112.0"
 fastapi_websocket_pubsub = "~0.3.8"

app/routes/issuer.py

@@ -13,8 +13,10 @@
     ClearPendingRevocationsResult,
     CreateOffer,
     CredentialType,
+    PendingRevocations,
     PublishRevocationsRequest,
     RevokeCredential,
+    RevokedResponse,
     SendCredential,
 )
 from app.services import revocation_registry
@@ -497,11 +499,11 @@ async def remove_credential_exchange_record(
     bound_logger.debug("Successfully deleted credential exchange record.")
 
 
-@router.post("/revoke", summary="Revoke a Credential (if revocable)", status_code=204)
+@router.post("/revoke", summary="Revoke a Credential (if revocable)")
 async def revoke_credential(
     body: RevokeCredential,
     auth: AcaPyAuth = Depends(acapy_auth_from_header),
-) -> None:
+) -> RevokedResponse:
     """
     Revoke a credential
     ---
@@ -523,20 +525,24 @@ async def revoke_credential(
 
     Returns:
     ---
-        status_code: 204
+        RevokedResponse:
+            revoked_cred_rev_ids:
+              The revocation registry indexes that were revoked.
+              Will be empty if the revocation was marked as pending.
     """
     bound_logger = logger.bind(body=body)
     bound_logger.debug("POST request received: Revoke credential")
 
     async with client_from_auth(auth) as aries_controller:
         bound_logger.debug("Revoking credential")
-        await revocation_registry.revoke_credential(
+        result = await revocation_registry.revoke_credential(
             controller=aries_controller,
             credential_exchange_id=body.credential_exchange_id,
             auto_publish_to_ledger=body.auto_publish_on_ledger,
         )
 
-    bound_logger.debug("Successfully revoked credential.")
+    bound_logger.info("Successfully revoked credential.")
+    return result
 
 
 @router.get(
@@ -609,13 +615,11 @@ async def get_credential_revocation_record(
     return revocation_record
 
 
-@router.post(
-    "/publish-revocations", summary="Publish Pending Revocations", status_code=204
-)
+@router.post("/publish-revocations", summary="Publish Pending Revocations")
 async def publish_revocations(
     publish_request: PublishRevocationsRequest,
     auth: AcaPyAuth = Depends(acapy_auth_from_header),
-) -> None:
+) -> RevokedResponse:
     """
     Write pending revocations to the ledger
     ---
@@ -647,18 +651,26 @@ async def publish_revocations(
 
     Returns:
     ---
-        status_code: 204
+        RevokedResponse:
+            revoked_cred_rev_ids:
+              The revocation registry indexes that were revoked.
+              Will be empty if there were no revocations to publish.
     """
     bound_logger = logger.bind(body=publish_request)
     bound_logger.debug("POST request received: Publish revocations")
 
     async with client_from_auth(auth) as aries_controller:
         bound_logger.debug("Publishing revocations")
-        endorser_transaction_id = await revocation_registry.publish_pending_revocations(
+        result = await revocation_registry.publish_pending_revocations(
             controller=aries_controller,
             revocation_registry_credential_map=publish_request.revocation_registry_credential_map,
         )
 
+        if not result:
+            bound_logger.debug("No revocations to publish.")
+            return RevokedResponse()
+
+        endorser_transaction_id = result.txn[0].transaction_id
         if endorser_transaction_id:
             bound_logger.debug(
                 "Wait for publish complete on transaction id: {}",
@@ -681,7 +693,8 @@ async def publish_revocations(
                     504,
                 ) from e
 
-    bound_logger.debug("Successfully published revocations.")
+    bound_logger.info("Successfully published revocations.")
+    return RevokedResponse.model_validate(result.model_dump())
 
 
 @router.post(
@@ -739,3 +752,39 @@ async def clear_pending_revocations(
 
     bound_logger.debug("Successfully cleared pending revocations.")
     return response
+
+
+@router.get(
+    "/get-pending-revocations/{revocation_registry_id}",
+    summary="Get Pending Revocations",
+)
+async def get_pending_revocations(
+    revocation_registry_id: str,
+    auth: AcaPyAuth = Depends(acapy_auth_from_header),
+) -> PendingRevocations:
+    """
+    Get pending revocations
+    ---
+    Get the pending revocations for a given revocation registry ID.
+
+    Parameters:
+    ---
+        revocation_registry_id: str
+            The ID of the revocation registry for which to fetch pending revocations
+
+    Returns:
+    ---
+        PendingRevocations:
+            A list of cred_rev_ids pending revocation for a given revocation registry ID
+    """
+    bound_logger = logger.bind(body={"revocation_registry_id": revocation_registry_id})
+    bound_logger.info("GET request received: Get pending revocations")
+
+    async with client_from_auth(auth) as aries_controller:
+        bound_logger.debug("Getting pending revocations")
+        result = await revocation_registry.get_pending_revocations(
+            controller=aries_controller, rev_reg_id=revocation_registry_id
+        )
+
+    bound_logger.info("Successfully fetched pending revocations.")
+    return PendingRevocations(pending_cred_rev_ids=result)

app/services/revocation_registry.py

@@ -10,14 +10,15 @@
     PublishRevocations,
     RevokeRequest,
     RevRegResult,
+    TxnOrPublishRevocationsResult,
 )
 
 from app.exceptions import (
     CloudApiException,
     handle_acapy_call,
     handle_model_with_validation,
 )
-from app.models.issuer import ClearPendingRevocationsResult
+from app.models.issuer import ClearPendingRevocationsResult, RevokedResponse
 from app.util.credentials import strip_protocol_prefix
 from app.util.retry_method import coroutine_with_retry
 from shared.log_config import get_logger
@@ -72,7 +73,7 @@ async def revoke_credential(
     controller: AcaPyClient,
     credential_exchange_id: str,
     auto_publish_to_ledger: bool = False,
-) -> None:
+) -> RevokedResponse:
     """
         Revoke an issued credential
 
@@ -103,7 +104,7 @@ async def revoke_credential(
         publish=auto_publish_to_ledger,
     )
     try:
-        await handle_acapy_call(
+        revoke_result = await handle_acapy_call(
             logger=bound_logger,
             acapy_call=controller.revocation.revoke_credential,
             body=request_body,
@@ -144,12 +145,27 @@ async def revoke_credential(
                 "Please check the revocation record state and retry if not revoked."
             )
 
-    bound_logger.debug("Successfully revoked credential.")
+        if not revoke_result:
+            raise CloudApiException(
+                "Revocation was published but no result was returned. "
+                "Has this credential been revoked before?"
+            )
+
+        if (
+            revoke_result
+            and revoke_result["txn"]
+            and revoke_result["txn"]["messages_attach"][0]
+        ):
+            bound_logger.info("Successfully revoked credential.")
+            return RevokedResponse.model_validate({"txn": [revoke_result["txn"]]})
+
+    bound_logger.info("Successfully revoked credential.")
+    return RevokedResponse()
 
 
 async def publish_pending_revocations(
     controller: AcaPyClient, revocation_registry_credential_map: Dict[str, List[str]]
-) -> Optional[str]:
+) -> TxnOrPublishRevocationsResult:
     """
         Publish pending revocations
 
@@ -181,19 +197,19 @@ async def publish_pending_revocations(
             f"Failed to publish pending revocations: {e.detail}", e.status_code
         ) from e
 
-    if not result.txn or not result.txn.transaction_id:
+    if not result.txn or not result.txn[0].transaction_id:
         bound_logger.warning(
             "Published pending revocations but received no endorser transaction id. Got result: {}",
             result,
         )
         return
 
-    endorse_transaction_id = result.txn.transaction_id
-    bound_logger.debug(
+    endorse_transaction_id = result.txn[0].transaction_id
+    bound_logger.info(
         "Successfully published pending revocations. Endorser transaction id: {}.",
         endorse_transaction_id,
     )
-    return endorse_transaction_id
+    return result
 
 
 async def clear_pending_revocations(
@@ -487,3 +503,38 @@ async def wait_for_active_registry(
         sleep_duration = 0.5  # Following sleeps should wait 0.5s before retry
 
     return active_registries
+
+
+async def get_pending_revocations(
+    controller: AcaPyClient, rev_reg_id: str
+) -> List[int]:
+    """
+    Get the pending revocations for a revocation registry.
+
+    Args:
+        controller (AcaPyClient): aca-py client
+        rev_reg_id (str): The revocation registry ID.
+
+    Raises:
+        Exception: When the pending revocations could not be retrieved.
+
+    Returns:
+        pending_revocations (List[str]): The pending revocations.
+    """
+    bound_logger = logger.bind(body={"rev_reg_id": rev_reg_id})
+    bound_logger.info("Fetching pending revocations for a revocation registry")
+
+    try:
+        result = await handle_acapy_call(
+            logger=bound_logger,
+            acapy_call=controller.revocation.get_registry,
+            rev_reg_id=rev_reg_id,
+        )
+    except CloudApiException as e:
+        raise CloudApiException(
+            f"Failed to get pending revocations: {e.detail}", e.status_code
+        ) from e
+
+    pending_revocations = result.result.pending_pub
+    bound_logger.info("Successfully retrieved pending revocations.")
+    return pending_revocations

app/tests/e2e/issuer/test_indy_credentials.py

@@ -1,4 +1,4 @@
 import asyncio
 
 import pytest
 from assertpy import assert_that
@@ -70,7 +70,7 @@
 
         assert_that(accept_response.status_code).is_equal_to(200)
         assert_that(oob_record).contains("created_at", "oob_id", "invitation")
         assert await check_webhook_state(
             client=alice_member_client,
             topic="credentials",
             state="offer-received",
@@ -160,7 +160,7 @@
 
     cred_ex_id = data["credential_exchange_id"]
     try:
         assert await check_webhook_state(
             client=faber_client,
             topic="credentials",
             state="offer-sent",
@@ -302,9 +302,10 @@
     response = await faber_client.post(
         f"{CREDENTIALS_BASE_PATH}/revoke",
         json={
-            "credential_definition_id": credential_definition_id_revocable,
             "credential_exchange_id": faber_credential_exchange_id,
+            "auto_publish_on_ledger": True,
         },
     )
 
-    assert response.status_code == 204
+    assert response.status_code == 200
+    assert len(response.json()["cred_rev_ids_published"]) == 1