🐛 Fix registering issuer did

app/pyproject.toml

@@ -51,4 +51,3 @@ profile = "black"
 [tool.pytest.ini_options]
 addopts = "--junitxml=junit.xml -p no:cacheprovider --cov-report=xml --cov-report=term"
 junit_family = "xunit2"
-asyncio_default_fixture_loop_scope = "function"

app/routes/revocation.py

@@ -17,6 +17,7 @@
 )
 from app.services import revocation_registry
 from app.util.retry_method import coroutine_with_retry_until_value
+from shared import PUBLISH_REVOCATIONS_TIMEOUT
 from shared.log_config import get_logger
 
 logger = get_logger(__name__)
@@ -209,7 +210,7 @@ async def publish_revocations(
                     field_name="state",
                     expected_value="transaction_acked",
                     logger=bound_logger,
-                    max_attempts=30,
+                    max_attempts=PUBLISH_REVOCATIONS_TIMEOUT,
                     retry_delay=1,
                 )
             except asyncio.TimeoutError as e:

app/services/definitions/credential_definitions.py

@@ -12,7 +12,7 @@
 from app.util.assert_public_did import assert_public_did
 from app.util.definitions import credential_definition_from_acapy
 from app.util.transaction_acked import wait_for_transaction_ack
-from shared import REGISTRY_SIZE
+from shared import CRED_DEF_ACK_TIMEOUT, REGISTRY_SIZE
 from shared.log_config import get_logger
 
 logger = get_logger(__name__)
@@ -58,7 +58,10 @@ async def create_credential_definition(
 
     if result.txn and result.txn.transaction_id:
         await wait_for_transaction_ack(
-            aries_controller=aries_controller, transaction_id=result.txn.transaction_id
+            aries_controller=aries_controller,
+            transaction_id=result.txn.transaction_id,
+            max_attempts=CRED_DEF_ACK_TIMEOUT,
+            retry_delay=1,
         )
 
     if support_revocation:

app/services/onboarding/issuer.py

@@ -6,7 +6,6 @@
 from app.services.onboarding.util.register_issuer_did import (
     create_connection_with_endorser,
     register_issuer_did,
-    wait_issuer_did_transaction_endorsed,
 )
 from app.util.did import qualified_did_sov
 from shared.log_config import get_logger
@@ -115,17 +114,11 @@ async def onboard_issuer_no_public_did(
         )
 
         issuer_did = await register_issuer_did(
-            endorser_controller=endorser_controller,
             issuer_controller=issuer_controller,
             issuer_label=issuer_label,
+            issuer_endorser_connection_id=issuer_connection_id,
             logger=bound_logger,
         )
-
-        await wait_issuer_did_transaction_endorsed(
-            issuer_controller=issuer_controller,
-            issuer_connection_id=issuer_connection_id,
-            logger=logger,
-        )
     except Exception as e:
         bound_logger.exception("Could not create connection with endorser.")
         raise CloudApiException(

app/services/onboarding/util/register_issuer_did.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from logging import Logger
 
 from aries_cloudcontroller import (
@@ -17,9 +16,7 @@
     set_endorser_info,
     set_endorser_role,
 )
-from shared import ACAPY_ENDORSER_ALIAS
-
-MAX_ATTEMPTS = int(os.getenv("WAIT_ISSUER_DID_MAX_ATTEMPTS", "15"))
+from shared import ACAPY_ENDORSER_ALIAS, ISSUER_DID_ENDORSE_TIMEOUT
 
 
 async def create_connection_with_endorser(
@@ -162,32 +159,46 @@ async def configure_endorsement(
 
 async def register_issuer_did(
     *,
-    endorser_controller: AcaPyClient,
     issuer_controller: AcaPyClient,
     issuer_label: str,
+    issuer_endorser_connection_id: str,
     logger: Logger,
 ) -> DID:
+    logger.debug("Accepting TAA on behalf of issuer")
+    await acapy_ledger.accept_taa_if_required(issuer_controller)
+
     logger.info("Creating DID for issuer")
     issuer_did = await acapy_wallet.create_did(issuer_controller)
 
     await acapy_ledger.register_nym_on_ledger(
-        endorser_controller,
+        issuer_controller,
         did=issuer_did.did,
         verkey=issuer_did.verkey,
         alias=issuer_label,
+        create_transaction_for_endorser=True,
+    )
+
+    logger.debug("Waiting for issuer DID transaction to be endorsed")
+    await wait_transactions_endorsed(  # Needs to be endorsed before setting public DID
+        issuer_controller=issuer_controller,
+        issuer_connection_id=issuer_endorser_connection_id,
+        logger=logger,
     )
 
-    logger.debug("Accepting TAA on behalf of issuer")
-    await acapy_ledger.accept_taa_if_required(issuer_controller)
-    # NOTE: Still needs endorsement in 0.7.5 release
-    # Otherwise did has no associated services.
     logger.debug("Setting public DID for issuer")
     await acapy_wallet.set_public_did(
         issuer_controller,
         did=issuer_did.did,
         create_transaction_for_endorser=True,
     )
 
+    logger.debug("Waiting for ATTRIB transaction to be endorsed")
+    await wait_transactions_endorsed(  # Needs to be endorsed before continuing
+        issuer_controller=issuer_controller,
+        issuer_connection_id=issuer_endorser_connection_id,
+        logger=logger,
+    )
+
     logger.debug("Issuer DID registered.")
     return issuer_did
 
@@ -239,12 +250,12 @@ async def wait_endorser_connection_completed(
     raise asyncio.TimeoutError
 
 
-async def wait_issuer_did_transaction_endorsed(
+async def wait_transactions_endorsed(
     *,
     issuer_controller: AcaPyClient,
     issuer_connection_id: str,
     logger: Logger,
-    max_attempts: int = MAX_ATTEMPTS,
+    max_attempts: int = ISSUER_DID_ENDORSE_TIMEOUT,
     retry_delay: float = 1.0,
 ) -> None:
     attempt = 0
@@ -255,19 +266,38 @@ async def wait_issuer_did_transaction_endorsed(
                 await issuer_controller.endorse_transaction.get_records()
             )
 
-            for transaction in transactions_response.results:
-                if (
-                    transaction.connection_id == issuer_connection_id
-                    and transaction.state == "transaction_acked"
-                ):
-                    return
+            transactions = [
+                transaction
+                for transaction in transactions_response.results
+                if transaction.connection_id == issuer_connection_id
+            ]
+
+            if not transactions:
+                logger.error(
+                    "No transactions found for connection {}. Found {} transactions.",
+                    issuer_connection_id,
+                    transactions_response,
+                )
+                raise CloudApiException("No transactions found for connection", 404)
+
+            all_acked = all(
+                transaction.state == "transaction_acked" for transaction in transactions
+            )
+
+            if all_acked:
+                return
+            else:
+                logger.debug(
+                    "Waiting for transaction acknowledgements. Current states: %s",
+                    ", ".join(f"{t.transaction_id}: {t.state}" for t in transactions),
+                )
 
         except Exception as e:  # pylint: disable=W0718
             if attempt + 1 == max_attempts:
                 logger.error(
                     "Maximum number of retries exceeded with exception. Failing."
                 )
-                raise asyncio.TimeoutError from e  # Raise TimeoutError if max attempts exceeded
+                raise asyncio.TimeoutError("Timeout waiting for endorsement") from e
 
             logger.warning(
                 (
@@ -284,4 +314,4 @@ async def wait_issuer_did_transaction_endorsed(
         attempt += 1
 
     logger.error("Maximum number of retries exceeded while waiting for transaction ack")
-    raise asyncio.TimeoutError
+    raise asyncio.TimeoutError("Timeout waiting for endorsement")

app/services/onboarding/util/set_endorser_metadata.py

@@ -13,7 +13,11 @@
 
 # todo: Migrate to endorser service
 async def set_endorser_role(
-    *, endorser_controller: AcaPyClient, endorser_connection_id: str, logger: Logger
+    *,
+    endorser_controller: AcaPyClient,
+    endorser_connection_id: str,
+    logger: Logger,
+    delay: float = DEFAULT_DELAY,
 ):
     try:
         logger.debug("Setting roles for endorser on endorser-issuer connection.")
@@ -24,7 +28,7 @@ async def set_endorser_role(
             transaction_my_job="TRANSACTION_ENDORSER",
         )
         logger.debug("Successfully set endorser role.")
-        await asyncio.sleep(DEFAULT_DELAY)  # Allow ACA-Py records to update
+        await asyncio.sleep(delay)  # Allow ACA-Py records to update
     except CloudApiException as e:
         logger.error("Failed to set endorser role: {}.", e)
         raise CloudApiException(
@@ -35,7 +39,11 @@ async def set_endorser_role(
 
 
 async def set_author_role(
-    *, issuer_controller: AcaPyClient, issuer_connection_id: str, logger: Logger
+    *,
+    issuer_controller: AcaPyClient,
+    issuer_connection_id: str,
+    logger: Logger,
+    delay: float = DEFAULT_DELAY,
 ):
     try:
         logger.debug("Setting roles for author on issuer-endorser connection")
@@ -46,7 +54,7 @@ async def set_author_role(
             transaction_my_job="TRANSACTION_AUTHOR",
         )
         logger.debug("Successfully set author role.")
-        await asyncio.sleep(DEFAULT_DELAY)  # Allow ACA-Py records to update
+        await asyncio.sleep(delay)  # Allow ACA-Py records to update
     except CloudApiException as e:
         logger.error("Failed to set author role: {}.", e)
         raise CloudApiException(
@@ -62,6 +70,7 @@ async def set_endorser_info(
     issuer_connection_id: str,
     endorser_did: str,
     logger: Logger,
+    delay: float = DEFAULT_DELAY,
 ):
     try:
         logger.debug("Setting endorser info on issuer-endorser connection")
@@ -72,7 +81,7 @@ async def set_endorser_info(
             endorser_did=endorser_did,
         )
         logger.debug("Successfully set endorser info.")
-        await asyncio.sleep(DEFAULT_DELAY)  # Allow ACA-Py records to update
+        await asyncio.sleep(delay)  # Allow ACA-Py records to update
     except CloudApiException as e:
         logger.error("Failed to set endorser info: {}.", e)
         raise CloudApiException(

app/tests/e2e/verifier/test_proof_revoked_credential.py

@@ -1,3 +1,4 @@
+import asyncio
 import time
 from typing import List
 
@@ -34,7 +35,7 @@ async def test_proof_revoked_credential(
     alice_member_client: RichAsyncClient,
     acme_and_alice_connection: AcmeAliceConnect,
 ):
-    time.sleep(10)  # moment for revocation registry to update
+    await asyncio.sleep(14)  # moment for revocation registry to update
     # todo: remove sleep when issue resolved: https://github.com/openwallet-foundation/acapy/issues/3018
 
     # Do proof request
@@ -124,7 +125,7 @@ async def test_regression_proof_revoked_credential(
     alice_member_client: RichAsyncClient,
     acme_and_alice_connection: AcmeAliceConnect,
 ):
-    time.sleep(10)  # moment for revocation registry to update
+    await asyncio.sleep(14)  # moment for revocation registry to update
     # todo: remove sleep when issue resolved: https://github.com/openwallet-foundation/acapy/issues/3018
 
     referent = get_or_issue_regression_cred_revoked.referent

app/tests/services/onboarding/test_onboarding.py

@@ -1,3 +1,5 @@
+from unittest.mock import AsyncMock, patch
+
 import pytest
 from aries_cloudcontroller import (
     DID,
@@ -88,22 +90,19 @@ async def test_onboard_issuer_no_public_did(
 
     endorser_controller = get_mock_agent_controller()
 
+    # Mock the necessary functions and methods
     when(acapy_wallet).get_public_did(controller=mock_agent_controller).thenRaise(
         CloudApiException(detail="Error")
     )
     when(acapy_wallet).get_public_did(controller=endorser_controller).thenReturn(
         to_async(did_object)
     )
-
     when(endorser_controller.out_of_band).create_invitation(...).thenReturn(
         to_async(InvitationRecord(invitation=InvitationMessage()))
     )
-
-    # Mock responses
     when(mock_agent_controller.out_of_band).receive_invitation(...).thenReturn(
         to_async(ConnRecord(connection_id=issuer_connection_id))
     )
-
     when(endorser_controller.connection).get_connections(...).thenReturn(
         to_async(
             ConnectionList(
@@ -115,20 +114,17 @@ async def test_onboard_issuer_no_public_did(
             )
         )
     )
-
     when(mock_agent_controller.endorse_transaction).set_endorser_role(...).thenReturn(
         to_async()
     )
-
     when(endorser_controller.endorse_transaction).set_endorser_role(...).thenReturn(
         to_async()
     )
     when(mock_agent_controller.endorse_transaction).set_endorser_info(...).thenAnswer(
         lambda conn_id, endorser_did: to_async()
     )
-
-    when(mock_agent_controller.endorse_transaction).get_records(...).thenReturn(
-        to_async(
+    when(mock_agent_controller.endorse_transaction).get_records(...).thenAnswer(
+        lambda: to_async(  # lambda to avoid "cannot reuse already awaited coroutine"
             TransactionList(
                 results=[
                     TransactionRecord(
@@ -138,7 +134,6 @@ async def test_onboard_issuer_no_public_did(
             )
         )
     )
-
     when(acapy_wallet).create_did(mock_agent_controller).thenReturn(
         to_async(did_object)
     )
@@ -156,27 +151,32 @@ async def test_onboard_issuer_no_public_did(
         )
     )
 
-    onboard_result = await issuer.onboard_issuer(
-        issuer_label="issuer_name",
-        endorser_controller=endorser_controller,
-        issuer_controller=mock_agent_controller,
-        issuer_wallet_id="issuer_wallet_id",
-    )
+    # Patch asyncio.sleep to return immediately
+    with patch("asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
+        onboard_result = await issuer.onboard_issuer(
+            issuer_label="issuer_name",
+            endorser_controller=endorser_controller,
+            issuer_controller=mock_agent_controller,
+            issuer_wallet_id="issuer_wallet_id",
+        )
 
+    # Assertions
     assert_that(onboard_result).has_did("did:sov:WgWxqztrNooG92RXvxSTWv")
+    verify(acapy_ledger).accept_taa_if_required(mock_agent_controller)
     verify(acapy_wallet).create_did(mock_agent_controller)
     verify(acapy_ledger).register_nym_on_ledger(
-        endorser_controller,
+        mock_agent_controller,
         did="WgWxqztrNooG92RXvxSTWv",
         verkey="WgWxqztrNooG92RXvxSTWvWgWxqztrNooG92RXvxSTWv",
         alias="issuer_name",
+        create_transaction_for_endorser=True,
     )
-    verify(acapy_ledger).accept_taa_if_required(mock_agent_controller)
     verify(acapy_wallet).set_public_did(
         mock_agent_controller,
         did="WgWxqztrNooG92RXvxSTWv",
         create_transaction_for_endorser=True,
     )
+    mock_sleep.assert_awaited()  # Ensure that sleep was called and patched
 
 
 @pytest.mark.anyio