fix: resolve the error related to profile context switching

Signed-off-by: Yuki I <omoge.real@gmail.com>

Author: Yuki I

acapy_agent/anoncreds/default/legacy_indy/registry.py

@@ -823,6 +823,7 @@ async def _revoc_reg_entry_with_fix(
                     rev_list.issuer_id,
                     write_ledger=write_ledger,
                     endorser_did=endorser_did,
+                    profile=profile,
                 )
         except LedgerTransactionError as err:
             if "InvalidClientRequest" in err.roll_up:
@@ -1209,20 +1210,23 @@ async def txn_submit(
         taa_accept: Optional[bool] = None,
         sign_did: DIDInfo = sentinel,
         write_ledger: bool = True,
+        profile: Optional[Profile] = None,
     ) -> str:
         """Submit a transaction to the ledger."""
 
         try:
             async with ledger:
-                return await shield(
-                    ledger.txn_submit(
-                        ledger_transaction,
-                        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 is not None:
+                    kwargs["profile"] = profile
+
+                return await shield(ledger.txn_submit(ledger_transaction, **kwargs))
         except LedgerError as err:
             raise AnonCredsRegistrationError(err.roll_up) from err
 

acapy_agent/ledger/indy_vdr.py

@@ -312,6 +312,7 @@ async def _submit(
         taa_accept: Optional[bool] = None,
         sign_did: DIDInfo = sentinel,
         write_ledger: bool = True,
+        profile: Optional[Profile] = None,  # <-- ADD profile parameter
     ) -> dict:
         """Sign and submit request to ledger.
 
@@ -321,9 +322,10 @@ async def _submit(
             taa_accept: whether to apply TAA acceptance to the (signed, write) request
             sign_did: override the signing DID
             write_ledger: whether to write the request to the ledger
-
+            profile: The profile context used for the request
         """
 
+        current_profile = profile or self.profile
         if not self.pool_handle:
             raise ClosedPoolError(
                 f"Cannot sign and submit request to closed pool '{self.pool_name}'"
@@ -336,7 +338,7 @@ async def _submit(
 
         if sign is None or sign:
             if sign_did is sentinel:
-                sign_did = await self.get_wallet_public_did()
+                sign_did = await self.get_wallet_public_did(profile=current_profile)
             if sign is None:
                 sign = bool(sign_did)
 
@@ -345,7 +347,9 @@ async def _submit(
                 raise BadLedgerRequestError("Cannot sign request without a public DID")
 
             if taa_accept or taa_accept is None:
-                acceptance = await self.get_latest_txn_author_acceptance()
+                acceptance = await self.get_latest_txn_author_acceptance(
+                    profile=current_profile
+                )
                 if acceptance:
                     acceptance = {
                         "taaDigest": acceptance["digest"],
@@ -354,12 +358,16 @@ async def _submit(
                     }
                     request.set_txn_author_agreement_acceptance(acceptance)
 
-            async with self.profile.session() as session:
+            async with current_profile.session() as session:
                 wallet = session.inject(BaseWallet)
-                request.set_signature(
-                    await wallet.sign_message(request.signature_input, sign_did.verkey)
-                )
-                del wallet
+                try:
+                    signature = await wallet.sign_message(
+                        message=request.signature_input,
+                        from_verkey=sign_did.verkey,
+                    )
+                    request.set_signature(signature)
+                except WalletNotFoundError as e:
+                    raise WalletNotFoundError("Missing key for sign operation") from e
 
         if not write_ledger:
             return json.loads(request.body)
@@ -368,6 +376,10 @@ async def _submit(
             request_result = await self.pool.handle.submit_request(request)
         except VdrError as err:
             raise LedgerTransactionError("Ledger request error") from err
+        except Exception as e:
+            raise LedgerTransactionError(
+                "Unexpected error during ledger submission"
+            ) from e
 
         return request_result
 
@@ -1003,15 +1015,18 @@ async def accept_txn_author_agreement(
             cache_key = TAA_ACCEPTED_RECORD_TYPE + "::" + self.profile.name
             await cache.set(cache_key, acceptance, self.pool.cache_duration)
 
-    async def get_latest_txn_author_acceptance(self) -> dict:
+    async def get_latest_txn_author_acceptance(
+        self, profile: Optional[Profile] = None
+    ) -> dict:
         """Look up the latest TAA acceptance."""
-        cache_key = TAA_ACCEPTED_RECORD_TYPE + "::" + self.profile.name
+        current_profile = profile or self.profile
+        cache_key = TAA_ACCEPTED_RECORD_TYPE + "::" + current_profile.name
         acceptance = self.pool.cache and await self.pool.cache.get(cache_key)
         if not acceptance:
             tag_filter = {"pool_name": self.pool_name}
-            async with self.profile.session() as session:
+            async with current_profile.session() as session:
                 storage = session.inject(BaseStorage)
-                cache = self.profile.inject_or(BaseCache)
+                cache = current_profile.inject_or(BaseCache)
                 found = await storage.find_all_records(
                     TAA_ACCEPTED_RECORD_TYPE, tag_filter
                 )
@@ -1226,24 +1241,34 @@ async def send_revoc_reg_entry(
         issuer_did: Optional[str] = None,
         write_ledger: bool = True,
         endorser_did: Optional[str] = None,
+        profile: Optional[Profile] = None,
     ) -> dict:
         """Publish a revocation registry entry to the ledger."""
-        async with self.profile.session() as session:
+
+        current_profile = profile or self.profile
+        async with current_profile.session() as session:
             wallet = session.inject(BaseWallet)
-            if issuer_did:
-                did_info = await wallet.get_local_did(issuer_did)
-            else:
+            try:
                 did_info = await wallet.get_public_did()
-            del wallet
+            except Exception:
+                raise
+            finally:
+                del wallet
+
         if not did_info:
             raise LedgerTransactionError(
                 "No issuer DID found for revocation registry entry"
             )
 
-        if self.profile.context.settings.get("wallet.type") == "askar-anoncreds":
-            from acapy_agent.anoncreds.default.legacy_indy.registry import (
-                LegacyIndyRegistry,
-            )
+        wallet_type = current_profile.context.settings.get("wallet.type")
+        if wallet_type == "askar-anoncreds":
+            try:
+                from acapy_agent.anoncreds.default.legacy_indy.registry import (
+                    LegacyIndyRegistry,
+                )
+
+            except ImportError:
+                raise
 
             revoc_reg_entry_req = await self._create_revoc_reg_entry_request(
                 did_info,
@@ -1253,17 +1278,23 @@ async def send_revoc_reg_entry(
                 write_ledger=write_ledger,
                 endorser_did=endorser_did,
             )
+
             if endorser_did and not write_ledger:
+                LOGGER.debug("Adding endorser to request")
                 revoc_reg_entry_req.set_endorser(endorser_did)
 
             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:
+                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,
+                )
+            except Exception:
+                raise
 
             if not write_ledger:
                 return revoc_reg_id, {"signed_txn": resp}
@@ -1284,22 +1315,36 @@ async def send_revoc_reg_entry(
                     revoc_def_type,
                     json.dumps(revoc_reg_entry),
                 )
+
                 if endorser_did and not write_ledger:
                     request.set_endorser(endorser_did)
+
             except VdrError as 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) -> DIDInfo:
+            try:
+                resp = await self._submit(
+                    request,
+                    True,
+                    sign_did=did_info,
+                    write_ledger=write_ledger,
+                    profile=current_profile,
+                )
+                return {"result": resp}
+            except Exception as err:
+                raise LedgerError(
+                    "Exception when sending revocation registry entry"
+                ) from err
+
+    async def get_wallet_public_did(self, profile: Optional[Profile] = None) -> DIDInfo:
         """Fetch the public DID from the wallet."""
-        async with self.profile.session() as session:
+        current_profile = profile or self.profile
+        async with current_profile.session() as session:
             wallet = session.inject(BaseWallet)
-            return await wallet.get_public_did()
+            public_did = await wallet.get_public_did()
+            return public_did
 
     async def txn_endorse(
         self,
@@ -1334,15 +1379,21 @@ async def txn_submit(
         taa_accept: Optional[bool] = None,
         sign_did: DIDInfo = sentinel,
         write_ledger: bool = True,
+        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}