fix: resolve the error related to profile context switching

Author: MonolithicMonk

acapy_agent/anoncreds/default/legacy_indy/registry.py

@@ -1134,7 +1134,6 @@ def _wallet_accumalator_matches_ledger_list(
                             rev_list.issuer_id,
                             write_ledger,
                             endorser_did,
-                            profile=profile,
                         )
 
         return (rev_reg_delta, recovery_txn, applied_txn)

acapy_agent/anoncreds/revocation.py

@@ -30,7 +30,9 @@
 from ..core.error import BaseError
 from ..core.event_bus import Event, EventBus
 from ..core.profile import Profile, ProfileSession
+from ..multitenant.base import BaseMultitenantManager
 from ..tails.anoncreds_tails_server import AnonCredsTailsServer
+from ..tails.base import BaseTailsServer
 from .error_messages import ANONCREDS_PROFILE_REQUIRED_MSG
 from .events import RevListFinishedEvent, RevRegDefFinishedEvent
 from .issuer import (
@@ -692,8 +694,14 @@ def get_local_tails_path(self, rev_reg_def: RevRegDef) -> str:
 
     async def upload_tails_file(self, rev_reg_def: RevRegDef):
         """Upload the local tails file to the tails server."""
-        tails_server = AnonCredsTailsServer()
+        multitenant_mgr = self.profile.inject_or(BaseMultitenantManager)
+        if multitenant_mgr:
+            tails_server = AnonCredsTailsServer()
+        else:
+            tails_server = self.profile.inject_or(BaseTailsServer)
 
+        if not tails_server:
+            raise AnonCredsRevocationError("Tails server not configured")
         if not Path(self.get_local_tails_path(rev_reg_def)).is_file():
             raise AnonCredsRevocationError("Local tails file not found")
 

acapy_agent/ledger/indy_vdr.py

@@ -373,9 +373,7 @@ async def _submit(
                         f"WalletNotFoundError in _submit: Missing key for verkey "
                         f"{sign_did.verkey}"
                         f"in wallet associated with profile ID "
-                        f"{current_profile.context.settings.get('wallet.id')}."
-                        f"Ledger profile ID was "
-                        f"{self.profile.context.settings.get('wallet.id')}.",
+                        f"{current_profile.context.settings.get('wallet.id')}.",
                         exc_info=True,
                     )
                     raise WalletNotFoundError(
@@ -1181,22 +1179,10 @@ async def send_revoc_reg_def(
         # NOTE - issuer DID could be extracted from the revoc_reg_def ID
         async with self.profile.session() as session:
             wallet = session.inject(BaseWallet)
-            LOGGER.debug("send_revoc_reg_def.Wallet instance: %s", wallet)
-            LOGGER.debug(
-                "send_revoc_reg_def.Profile context: %s", self.profile.context.settings
-            )
             if issuer_did:
                 did_info = await wallet.get_local_did(issuer_did)
-                LOGGER.debug(
-                    "send_revoc_reg_def.Local DID retrieved for issuer_did '%s': %s",
-                    issuer_did,
-                    did_info,
-                )
             else:
                 did_info = await wallet.get_public_did()
-                LOGGER.debug(
-                    "send_revoc_reg_def.Public DID retrieved from wallet: %s", did_info
-                )
             del wallet
         if not did_info:
             raise LedgerTransactionError(
@@ -1226,7 +1212,6 @@ async def send_revoc_reg_def(
                     sign=True,
                     sign_did=did_info,
                     write_ledger=write_ledger,
-                    profile=self.profile,
                 )
             except LedgerError as err:
                 raise LedgerError(
@@ -1272,21 +1257,56 @@ async def send_revoc_reg_entry(
         profile: Optional[Profile] = None,
     ) -> dict:
         """Publish a revocation registry entry to the ledger."""
+        LOGGER.debug(">>> Entered send_revoc_reg_entry")
+        LOGGER.debug(
+            f"Initial parameters - issuer_did: {issuer_did}, write_ledger: {write_ledger}, endorser_did: {endorser_did}"  # noqa: E501
+        )
+
         current_profile = profile or self.profile
+        LOGGER.debug(
+            f"Using profile: {'provided profile' if profile else 'self.profile'}"
+        )
+
         async with current_profile.session() as session:
             wallet = session.inject(BaseWallet)
-            did_info = await wallet.get_public_did()
-            del wallet
+            LOGGER.debug("Retrieved wallet instance: %s", type(wallet).__name__)
+
+            try:
+                did_info = await wallet.get_public_did()
+                LOGGER.debug(f"Public DID info: {did_info}")
+            except Exception as e:
+                LOGGER.error("Error during DID resolution: %s", str(e))
+                raise
+            finally:
+                del wallet
+
         if not did_info:
+            LOGGER.error("No DID info found for revocation registry entry")
             raise LedgerTransactionError(
                 "No issuer DID found for revocation registry entry"
             )
 
-        if current_profile.context.settings.get("wallet.type") == "askar-anoncreds":
-            from acapy_agent.anoncreds.default.legacy_indy.registry import (
-                LegacyIndyRegistry,
-            )
+        LOGGER.debug(f"Final DID used: {did_info.did} (verkey: {did_info.verkey})")
 
+        # Wallet type check
+        wallet_type = current_profile.context.settings.get("wallet.type")
+        LOGGER.debug(
+            f"Wallet type evaluation: {wallet_type} (comparison to 'askar-anoncreds')"
+        )
+
+        if wallet_type == "askar-anoncreds":
+            LOGGER.debug(">>> Entering askar-anoncreds path")
+            try:
+                from acapy_agent.anoncreds.default.legacy_indy.registry import (  # noqa: F401
+                    LegacyIndyRegistry,
+                )
+
+                LOGGER.debug("Successfully imported LegacyIndyRegistry")
+            except ImportError as e:
+                LOGGER.error("Import error: %s", str(e))
+                raise
+
+            LOGGER.debug("Building revoc_reg_entry request")
             revoc_reg_entry_req = await self._create_revoc_reg_entry_request(
                 did_info,
                 revoc_reg_id,
@@ -1295,47 +1315,80 @@ async def send_revoc_reg_entry(
                 write_ledger=write_ledger,
                 endorser_did=endorser_did,
             )
+            LOGGER.debug(f"Request type created: {type(revoc_reg_entry_req).__name__}")
+
             if endorser_did and not write_ledger:
+                LOGGER.debug("Adding endorser to request")
                 revoc_reg_entry_req.set_endorser(endorser_did)
 
+            # Transaction submission
+            LOGGER.debug("Initializing LegacyIndyRegistry")
             legacy_indy_registry = LegacyIndyRegistry()
-            resp = await legacy_indy_registry.txn_submit(
-                self,
-                revoc_reg_entry_req,
-                sign=True,
-                sign_did=did_info,
-                write_ledger=write_ledger,
-            )
+            try:
+                LOGGER.debug("Submitting transaction via LegacyIndyRegistry")
+                resp = await legacy_indy_registry.txn_submit(
+                    self,
+                    revoc_reg_entry_req,
+                    sign=True,
+                    sign_did=did_info,
+                    write_ledger=write_ledger,
+                    profile=current_profile,
+                )
+                LOGGER.debug("Received response from LegacyIndyRegistry")
+            except Exception as e:
+                LOGGER.error("Error in LegacyIndyRegistry submission: %s", str(e))
+                raise
 
             if not write_ledger:
+                LOGGER.debug("Write ledger disabled, returning unsigned response")
                 return revoc_reg_id, {"signed_txn": resp}
 
             try:
                 # parse sequence number out of response
+                LOGGER.debug("Attempting to parse sequence number")
                 seq_no = json.loads(resp)["result"]["txnMetadata"]["seqNo"]
+                LOGGER.debug(f"Parsed sequence number: {seq_no}")
                 return seq_no
             except KeyError as err:
+                LOGGER.error("Key error parsing response: %s", str(err))
+                LOGGER.debug("Full response content: %s", resp)
                 raise LedgerError(
                     "Failed to parse sequence number from ledger response"
                 ) from err
         else:
+            LOGGER.debug(">>> Entering default Indy-VDR path")
             try:
+                LOGGER.debug("Building standard revoc_reg_entry request")
                 request = ledger.build_revoc_reg_entry_request(
                     did_info.did,
                     revoc_reg_id,
                     revoc_def_type,
                     json.dumps(revoc_reg_entry),
                 )
+                LOGGER.debug(f"Request type created: {type(request).__name__}")
+
                 if endorser_did and not write_ledger:
+                    LOGGER.debug("Adding endorser to request")
                     request.set_endorser(endorser_did)
+
             except VdrError as err:
+                LOGGER.error("VdrError in request building: %s", str(err))
+                raise LedgerError(
+                    "Exception when sending revocation registry entry"
+                ) from err
+
+            try:
+                LOGGER.debug("Submitting to ledger")
+                resp = await self._submit(
+                    request, True, sign_did=did_info, write_ledger=write_ledger
+                )
+                LOGGER.debug("Received ledger response")
+                return {"result": resp}
+            except Exception as err:
+                LOGGER.error("Error during ledger submission: %s", str(err))
                 raise LedgerError(
                     "Exception when sending revocation registry entry"
                 ) from err
-            resp = await self._submit(
-                request, True, sign_did=did_info, write_ledger=write_ledger
-            )
-            return {"result": resp}
 
     async def get_wallet_public_did(self, profile: Optional[Profile] = None) -> DIDInfo:
         """Fetch the public DID from the wallet."""
@@ -1381,13 +1434,18 @@ async def txn_submit(
         profile: Optional[Profile] = None,
     ) -> str:
         """Write the provided (signed and possibly endorsed) transaction to the ledger."""
-        resp = await self._submit(
-            request_json,
-            sign=sign,
-            taa_accept=taa_accept,
-            sign_did=sign_did,
-            write_ledger=write_ledger,
-        )
+        kwargs = {
+            "sign": sign,
+            "taa_accept": taa_accept,
+            "sign_did": sign_did,
+            "write_ledger": write_ledger,
+        }
+
+        if profile:
+            kwargs["profile"] = profile
+
+        resp = await self._submit(request_json, **kwargs)
+
         if write_ledger:
             # match the format returned by indy sdk
             resp = {"op": "REPLY", "result": resp}