iwa 0.0.33__py3-none-any.whl → 0.0.59__py3-none-any.whl

iwa/plugins/olas/importer.py

@@ -181,9 +181,7 @@ class OlasServiceImporter:
             if service.service_id:
                 key = f"{service.chain_name}:{service.service_id}"
                 if key in seen_keys:
-                    logger.debug(
-                        f"Skipping duplicate service {key} from {service.source_folder}"
-                    )
+                    logger.debug(f"Skipping duplicate service {key} from {service.source_folder}")
                     duplicates += 1
                     continue
                 seen_keys.add(key)
@@ -482,9 +480,7 @@ class OlasServiceImporter:
                     staking_program_id, chain_name
                 )
 
-    def _resolve_staking_contract(
-        self, staking_program_id: str, chain_name: str
-    ) -> Optional[str]:
+    def _resolve_staking_contract(self, staking_program_id: str, chain_name: str) -> Optional[str]:
         """Resolve a staking program ID to a contract address."""
         address = STAKING_PROGRAM_MAP.get(staking_program_id)
         if address:
@@ -540,8 +536,10 @@ class OlasServiceImporter:
 
                 # Check for "safes" entry which indicates the owner is a Safe
                 # Structure: "safes": { "gnosis": "0x..." }
-                if "safes" in data and FLAGS_OWNER_SAFE in data["safes"]: # Need to detect chain dynamically or iterate
-                     pass
+                if (
+                    "safes" in data and FLAGS_OWNER_SAFE in data["safes"]
+                ):  # Need to detect chain dynamically or iterate
+                    pass
 
                 # Logic update:
                 # 1. Capture EOA address always (it's the signer)
@@ -557,9 +555,13 @@ class OlasServiceImporter:
                 if safe_owner_address:
                     # CASE: Owner is Safe
                     service.service_owner_multisig_address = safe_owner_address
-                    service.service_owner_eoa_address = eoa_address # The EOA is the signer/controller
+                    service.service_owner_eoa_address = (
+                        eoa_address  # The EOA is the signer/controller
+                    )
 
-                    logger.debug(f"Extracted Safe owner address: {safe_owner_address} (Signer: {eoa_address})")
+                    logger.debug(
+                        f"Extracted Safe owner address: {safe_owner_address} (Signer: {eoa_address})"
+                    )
                 elif eoa_address:
                     # CASE: Owner is EOA
                     service.service_owner_eoa_address = eoa_address
@@ -767,8 +769,8 @@ class OlasServiceImporter:
             safe_result = self._import_safe(
                 address=service.safe_address,
                 signers=self._get_agent_signers(service),
-                tag_suffix="safe", # e.g. trader_zeta_safe
-                service_name=service.service_name
+                tag_suffix="multisig",  # e.g. trader_zeta_safe
+                service_name=service.service_name,
             )
             if safe_result[0]:
                 result.imported_safes.append(service.safe_address)
@@ -778,19 +780,22 @@ class OlasServiceImporter:
                 result.errors.append(f"Safe {service.safe_address}: {safe_result[1]}")
 
         # 2. Import Owner Safe (if it exists and is different)
-        if service.service_owner_multisig_address and service.service_owner_multisig_address != service.safe_address:
-             # Signer for Owner Safe is the EOA owner key
+        if (
+            service.service_owner_multisig_address
+            and service.service_owner_multisig_address != service.safe_address
+        ):
+            # Signer for Owner Safe is the EOA owner key
             owner_signers = self._get_owner_signers(service)
 
             safe_result = self._import_safe(
                 address=service.service_owner_multisig_address,
                 signers=owner_signers,
-                tag_suffix="owner_safe", # e.g. trader_zeta_owner_safe
-                service_name=service.service_name
+                tag_suffix="owner_multisig",  # e.g. trader_zeta_owner_safe
+                service_name=service.service_name,
             )
             if safe_result[0]:
-                 result.imported_safes.append(service.service_owner_multisig_address)
-                 logger.info(f"Imported Owner Safe {service.service_owner_multisig_address}")
+                result.imported_safes.append(service.service_owner_multisig_address)
+                logger.info(f"Imported Owner Safe {service.service_owner_multisig_address}")
 
     def _get_agent_signers(self, service: DiscoveredService) -> List[str]:
         """Get list of signers for the agent safe."""
@@ -878,8 +883,7 @@ class OlasServiceImporter:
                 self.key_storage._password,
                 tag,
             )
-            self.key_storage.accounts[encrypted.address] = encrypted
-            self.key_storage.save()
+            self.key_storage.register_account(encrypted)
             logger.info(f"Imported key {key.address} as '{tag}'")
             return True, "ok"
         except Exception as e:
@@ -926,8 +930,8 @@ class OlasServiceImporter:
         self,
         address: str,
         signers: List[str] = None,
-        tag_suffix: str = "safe",
-        service_name: Optional[str] = None
+        tag_suffix: str = "multisig",
+        service_name: Optional[str] = None,
     ) -> Tuple[bool, str]:
         """Import a generic Safe."""
         if not address:
@@ -960,8 +964,7 @@ class OlasServiceImporter:
             signers=signers or [],
         )
 
-        self.key_storage.accounts[address] = safe_account
-        self.key_storage.save()
+        self.key_storage.register_account(safe_account)
         logger.info(f"Imported Safe {address} as '{tag}'")
         return True, "ok"
 
@@ -1064,4 +1067,5 @@ class OlasServiceImporter:
             key.signature_failed = True
             logger.warning(f"Error verifying signature for key {key.address}: {e}")
 
-FLAGS_OWNER_SAFE="deprecated"
+
+FLAGS_OWNER_SAFE = "deprecated"

iwa/plugins/olas/models.py

@@ -134,8 +134,5 @@ class OlasConfig(BaseModel):
         target = multisig_address.lower()
         for service in self.services.values():
             if service.multisig_address and str(service.multisig_address).lower() == target:
-                # The following line is from the Code Edit, but it does not fit syntactically here.
-                # It appears to be from a different file (decoder.py) as indicated by the instruction.
-                # args_str = ", ".join(f"{n}={v}" for n, v in zip(d["arg_names"], decoded, strict=False))
                 return service
         return None

iwa/plugins/olas/plugin.py

@@ -151,7 +151,9 @@ class OlasPlugin(Plugin):
 
                     is_signer = key_addr in [s.lower() for s in on_chain_signers]
                     if not is_signer:
-                        safe_text += f"\n[bold red]⚠ Agent {agent_key.address} - NOT A SIGNER![/bold red]"
+                        safe_text += (
+                            f"\n[bold red]⚠ Agent {agent_key.address} - NOT A SIGNER![/bold red]"
+                        )
                     else:
                         safe_text += f" (Signer: {agent_key.address[:6]}...)"
 
@@ -182,21 +184,21 @@ class OlasPlugin(Plugin):
         # 1. Display Signer/EOA Owner
         owner_key = next((k for k in service.keys if k.role == "owner"), None)
         if owner_key:
-             val = owner_key.address
-             if not val.startswith("0x"):
-                 val = "0x" + val
-
-             if owner_key.signature_verified:
-                 val = f"[green]{val}[/green]"
-             elif not owner_key.is_encrypted:
-                 val = f"[red]{val}[/red]"
-             status = "🔒 encrypted" if owner_key.is_encrypted else "🔓 plaintext"
-             table.add_row("Owner (EOA)", f"{val} {status}")
+            val = owner_key.address
+            if not val.startswith("0x"):
+                val = "0x" + val
+
+            if owner_key.signature_verified:
+                val = f"[green]{val}[/green]"
+            elif not owner_key.is_encrypted:
+                val = f"[red]{val}[/red]"
+            status = "🔒 encrypted" if owner_key.is_encrypted else "🔓 plaintext"
+            table.add_row("Owner (EOA)", f"{val} {status}")
         elif service.service_owner_eoa_address:
-             # Fallback if we have an address but no key object
-             table.add_row("Owner (EOA)", service.service_owner_eoa_address)
+            # Fallback if we have an address but no key object
+            table.add_row("Owner (EOA)", service.service_owner_eoa_address)
         else:
-             table.add_row("Owner (EOA)", "[yellow]N/A[/yellow]")
+            table.add_row("Owner (EOA)", "[yellow]N/A[/yellow]")
 
         # 2. Display Safe Owner
         if service.service_owner_multisig_address:

iwa/plugins/olas/service_manager/drain.py

@@ -107,12 +107,18 @@ class DrainManagerMixin:
             logger.error("Service has no multisig address")
             return False, 0
 
-        if not self.olas_config.withdrawal_address:
-            logger.error("No withdrawal address configured in OlasConfig")
-            return False, 0
-
+        withdrawal_address = (
+            str(self.olas_config.withdrawal_address)
+            if self.olas_config.withdrawal_address
+            else str(self.wallet.master_account.address)
+        )
         multisig_address = str(self.service.multisig_address)
-        withdrawal_address = str(self.olas_config.withdrawal_address)
+
+        if not self.olas_config.withdrawal_address:
+            logger.warning(
+                "No withdrawal address configured. Defaulting to master account: "
+                f"{withdrawal_address}"
+            )
 
         # Get OLAS balance of the Safe
         olas_token = ERC20Contract(
@@ -126,9 +132,10 @@ class DrainManagerMixin:
             return False, 0
 
         olas_amount = olas_balance / 1e18
-        logger.info(
-            f"Withdrawing {olas_amount:.4f} OLAS from {multisig_address} to {withdrawal_address}"
-        )
+        withdrawal_tag = self.wallet.get_tag_by_address(withdrawal_address) or withdrawal_address
+        multisig_tag = self.wallet.get_tag_by_address(multisig_address) or multisig_address
+
+        logger.info(f"Withdrawing {olas_amount:.4f} OLAS from {multisig_tag} to {withdrawal_tag}")
 
         # Transfer from Safe to withdrawal address
         tx_hash = self.wallet.send(
@@ -143,7 +150,7 @@ class DrainManagerMixin:
             logger.error("Failed to transfer OLAS")
             return False, 0
 
-        logger.info(f"Withdrew {olas_amount:.4f} OLAS to {withdrawal_address}")
+        logger.info(f"Withdrew {olas_amount:.4f} OLAS to {withdrawal_tag}")
         return True, olas_amount
 
     def drain_service(

iwa/plugins/olas/service_manager/lifecycle.py

@@ -429,9 +429,7 @@ class LifecycleManagerMixin:
             )
 
             if balance < bond_amount:
-                logger.error(
-                    f"[ACTIVATE] FAIL: Owner balance {balance} < required {bond_amount}"
-                )
+                logger.error(f"[ACTIVATE] FAIL: Owner balance {balance} < required {bond_amount}")
                 return False
 
             protocol_contracts = OLAS_CONTRACTS.get(self.chain_name.lower(), {})
@@ -632,7 +630,7 @@ class LifecycleManagerMixin:
         # Use service_name for consistency with Safe naming
         agent_tag = f"{self.service.service_name}_agent"
         try:
-            agent_account = self.wallet.key_storage.create_account(agent_tag)
+            agent_account = self.wallet.key_storage.generate_new_account(agent_tag)
             agent_account_address = agent_account.address
             logger.info(f"Created new agent account: {agent_account_address}")
 
@@ -682,7 +680,9 @@ class LifecycleManagerMixin:
                 )
                 return True
 
-        logger.info(f"[REGISTER] Service Owner approving Token Utility for bond: {bond_amount_wei} wei")
+        logger.info(
+            f"[REGISTER] Service Owner approving Token Utility for bond: {bond_amount_wei} wei"
+        )
 
         utility_address = str(
             OLAS_CONTRACTS[self.chain_name]["OLAS_SERVICE_REGISTRY_TOKEN_UTILITY"]
@@ -697,9 +697,7 @@ class LifecycleManagerMixin:
         )
 
         if allowance >= bond_amount_wei:
-            logger.debug(
-                f"[REGISTER] Sufficient allowance ({allowance} >= {bond_amount_wei})"
-            )
+            logger.debug(f"[REGISTER] Sufficient allowance ({allowance} >= {bond_amount_wei})")
             return True
 
         # Use service owner which holds the OLAS tokens (not necessarily master)
@@ -800,7 +798,9 @@ class LifecycleManagerMixin:
             )
             return False
 
-        logger.debug(f"[DEPLOY] Preparing deploy tx for owner {self._get_label(self.service.service_owner_address)}")
+        logger.debug(
+            f"[DEPLOY] Preparing deploy tx for owner {self._get_label(self.service.service_owner_address)}"
+        )
         deploy_tx = self.manager.prepare_deploy_tx(
             from_address=self.service.service_owner_address,
             service_id=self.service.service_id,
@@ -855,16 +855,27 @@ class LifecycleManagerMixin:
             _, agent_instances = self.registry.call("getAgentInstances", self.service.service_id)
             service_info = self.registry.get_service(self.service.service_id)
             threshold = service_info["threshold"]
+            # Store the multisig in the wallet with tag
+            multisig_tag = f"{self.service.service_name}_multisig"
+
+            # ARCHIVING LOGIC: If tag is already taken by a different address, rename the old one
+            existing = self.wallet.key_storage.find_stored_account(multisig_tag)
+            if existing and existing.address != multisig_address:
+                archive_tag = f"{multisig_tag}_old_{existing.address[:6]}"
+                logger.info(f"[DEPLOY] Archiving old multisig: {multisig_tag} -> {archive_tag}")
+                try:
+                    self.wallet.key_storage.rename_account(existing.address, archive_tag)
+                except Exception as ex:
+                    logger.warning(f"[DEPLOY] Failed to rename old multisig (collision?): {ex}")
 
             safe_account = StoredSafeAccount(
-                tag=f"{self.service.service_name}_multisig",
+                tag=multisig_tag,
                 address=multisig_address,
                 chains=[self.chain_name],
                 threshold=threshold,
                 signers=agent_instances,
             )
-            self.wallet.key_storage.accounts[multisig_address] = safe_account
-            self.wallet.key_storage.save()
+            self.wallet.key_storage.register_account(safe_account)
             logger.debug("[DEPLOY] Registered multisig in wallet")
         except Exception as e:
             logger.warning(f"[DEPLOY] Failed to register multisig in wallet: {e}")

iwa/plugins/olas/service_manager/staking.py

@@ -90,6 +90,7 @@ class StakingManagerMixin:
         # Try token/contract names
         try:
             from iwa.core.chain import ChainInterfaces
+
             chain_interface = ChainInterfaces().get(self.chain_name)
             token_name = chain_interface.chain.get_token_name(address)
             if token_name:
@@ -211,14 +212,14 @@ class StakingManagerMixin:
         # Helper to safely get min_staking_duration
         try:
             min_duration = staking.min_staking_duration
-            logger.info(f"min_staking_duration: {min_duration}")
+            logger.debug(f"min_staking_duration: {min_duration}")
         except Exception as e:
             logger.error(f"Failed to get min_staking_duration: {e}")
             min_duration = 0
 
         unstake_at = None
         ts_start = info.get("ts_start", 0)
-        logger.info(f"ts_start: {ts_start}")
+        logger.debug(f"ts_start: {ts_start}")
 
         if ts_start > 0:
             try:
@@ -227,12 +228,12 @@ class StakingManagerMixin:
                     unstake_ts,
                     tz=timezone.utc,
                 ).isoformat()
-                logger.info(f"unstake_available_at: {unstake_at} (ts={unstake_ts})")
+                logger.debug(f"unstake_available_at: {unstake_at} (ts={unstake_ts})")
             except Exception as e:
                 logger.error(f"calc error: {e}")
                 pass
         else:
-            logger.warning("ts_start is 0, cannot calculate unstake time")
+            logger.debug("ts_start is 0, cannot calculate unstake time")
 
         return unstake_at, ts_start, min_duration
 
@@ -407,7 +408,9 @@ class StakingManagerMixin:
         # NOTE: We don't check OLAS balance here because OLAS was already
         # deposited to the Token Utility during activation (min_staking_deposit)
         # and registration (agent_bond). The staking contract pulls from there.
-        logger.debug("[STAKE] OLAS already deposited to Token Utility during activation/registration")
+        logger.debug(
+            "[STAKE] OLAS already deposited to Token Utility during activation/registration"
+        )
 
         return {"min_deposit": min_deposit, "staking_token": staking_token}
 
@@ -437,7 +440,9 @@ class StakingManagerMixin:
         owner_address = self.service.service_owner_address or self.wallet.master_account.address
 
         # Approve service NFT - this is an ERC-721 approval, not ERC-20
-        logger.debug(f"[STAKE] Approving service NFT for staking contract from {self._get_label(owner_address)}...")
+        logger.debug(
+            f"[STAKE] Approving service NFT for staking contract from {self._get_label(owner_address)}..."
+        )
         approve_tx = self.registry.prepare_approve_tx(
             from_address=owner_address,
             spender=staking_contract.address,
@@ -483,7 +488,9 @@ class StakingManagerMixin:
         # Use service owner which holds the NFT (not necessarily master)
         owner_address = self.service.service_owner_address or self.wallet.master_account.address
 
-        logger.debug(f"[STAKE] Preparing stake transaction from {self._get_label(owner_address)}...")
+        logger.debug(
+            f"[STAKE] Preparing stake transaction from {self._get_label(owner_address)}..."
+        )
         stake_tx = staking_contract.prepare_stake_tx(
             from_address=owner_address,
             service_id=self.service.service_id,
@@ -601,9 +608,7 @@ class StakingManagerMixin:
             return False
 
         tx_hash = get_tx_hash(receipt)
-        logger.info(
-            f"Unstake transaction sent: {tx_hash if receipt else 'No Receipt'}"
-        )
+        logger.info(f"Unstake transaction sent: {tx_hash if receipt else 'No Receipt'}")
 
         events = staking_contract.extract_events(receipt)
 

iwa/plugins/olas/tests/test_importer_error_handling.py

@@ -296,6 +296,12 @@ def test_import_key_success(importer):
     importer.key_storage.find_stored_account.return_value = None
     importer.key_storage.accounts = {}
 
+    # Define side effect to update accounts dict when register_account is called
+    def mock_register(acc):
+        importer.key_storage.accounts[acc.address] = acc
+
+    importer.key_storage.register_account.side_effect = mock_register
+
     with patch("iwa.core.keys.EncryptedAccount.encrypt_private_key") as mock_enc:
         mock_enc.return_value = MagicMock(address=addr)
         success, msg = importer._import_key(key, "my_service")
@@ -310,10 +316,17 @@ def test_import_safe_success(importer):
     importer.key_storage.find_stored_account.return_value = None
     importer.key_storage.accounts = {}
 
+    # Define side effect to update accounts dict when register_account is called
+    def mock_register(acc):
+        importer.key_storage.accounts[acc.address] = acc
+
+    importer.key_storage.register_account.side_effect = mock_register
+
     success, msg = importer._import_safe(safe_address, service_name="my_service")
     assert success is True
     assert msg == "ok"
     assert safe_address in importer.key_storage.accounts
+    assert importer.key_storage.accounts[safe_address].tag == "my_service_multisig"
 
 
 def test_import_service_config_success(importer):

iwa/plugins/olas/tests/test_olas_archiving.py

@@ -0,0 +1,83 @@
+"""Tests for Olas multisig archiving logic."""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from iwa.core.models import StoredAccount
+from iwa.plugins.olas.contracts.service import ServiceState
+from iwa.plugins.olas.models import Service
+from iwa.plugins.olas.service_manager import ServiceManager
+
+
+class TestOlasArchiving(unittest.TestCase):
+    """Test multisig archiving logic during deployment."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.mock_wallet = MagicMock()
+        # Mock KeyStorage
+        self.mock_key_storage = MagicMock()
+        self.mock_wallet.key_storage = self.mock_key_storage
+
+        # Initialize ServiceManager
+        with (
+            patch("iwa.core.models.Config"),
+            patch("iwa.plugins.olas.service_manager.base.ChainInterfaces"),
+            patch("iwa.plugins.olas.service_manager.base.ContractCache"),
+            patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract"),
+        ):
+            self.sm = ServiceManager(self.mock_wallet)
+            self.sm.service = Service(service_name="trader_psi", chain_name="gnosis", service_id=1)
+            self.sm.chain_name = "gnosis"
+
+    def test_multisig_archiving_logic(self):
+        """Test that old multisig is archived if tag is taken by different address."""
+        multisig_tag = "trader_psi_multisig"
+        old_address = "0x1111111111111111111111111111111111111111"
+        new_address = "0x2222222222222222222222222222222222222222"
+
+        # 1. Simulate existing multisig in wallet with same tag
+        existing_acc = StoredAccount(address=old_address, tag=multisig_tag)
+        self.mock_key_storage.find_stored_account.return_value = existing_acc
+
+        # 2. Mock required contract calls for deploy()
+        self.sm.registry.get_service.return_value = {
+            "state": ServiceState.FINISHED_REGISTRATION,  # DEPLOYED
+            "security_deposit": 0,
+            "multisig": new_address,
+            "threshold": 1,
+            "configHash": b"\x00" * 32,
+        }
+        self.sm.registry.call.return_value = (None, [])  # getAgentInstances
+
+        # 3. Trigger deploy (archiving happens here)
+        with (
+            patch.object(
+                self.mock_wallet, "sign_and_send_transaction", return_value=(True, {"status": 1})
+            ),
+            patch.object(
+                self.sm.registry,
+                "extract_events",
+                return_value=[
+                    {"name": "DeployService", "args": {}},
+                    {"name": "CreateMultisigWithAgents", "args": {"multisig": new_address}},
+                ],
+            ),
+            patch("iwa.plugins.olas.service_manager.lifecycle.get_tx_hash", return_value="0xhash"),
+            patch("iwa.core.models.StoredSafeAccount") as mock_safe_cls,
+        ):
+            self.sm.deploy(fund_multisig=False)
+
+            # 4. Verify rename_account was called for the old address
+            archive_tag = f"{multisig_tag}_old_{old_address[:6]}"
+            self.mock_key_storage.rename_account.assert_called_with(old_address, archive_tag)
+
+            # 5. Verify new account constructor was called with correct params
+            mock_safe_cls.assert_called()
+            _, kwargs = mock_safe_cls.call_args
+            self.assertEqual(kwargs["address"], new_address)
+            self.assertEqual(kwargs["tag"], multisig_tag)
+
+
+if __name__ == "__main__":
+    unittest.main()

iwa/plugins/olas/tests/test_olas_integration.py

@@ -309,9 +309,11 @@ def test_importer_import_service_config_duplicate(mock_wallet):
 
 def test_sm_create_token_utility_missing(mock_wallet):
     """Cover create() with missing token utility (lines 204-206)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
 
@@ -323,9 +325,11 @@ def test_sm_create_token_utility_missing(mock_wallet):
 
 def test_sm_get_staking_status_staked_info_fail(mock_wallet):
     """Cover get_staking_status with STAKED but get_service_info fails (lines 843-854)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(
@@ -347,9 +351,11 @@ def test_sm_get_staking_status_staked_info_fail(mock_wallet):
 
 def test_sm_call_checkpoint_prepare_fail(mock_wallet):
     """Cover call_checkpoint prepare failure (lines 1100-1102)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(
@@ -369,9 +375,11 @@ def test_sm_call_checkpoint_prepare_fail(mock_wallet):
 
 def test_sm_spin_up_no_service(mock_wallet):
     """Cover spin_up with no service (lines 1167-1170)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
@@ -382,9 +390,11 @@ def test_sm_spin_up_no_service(mock_wallet):
 
 def test_sm_spin_up_activation_fail(mock_wallet):
     """Cover spin_up activation failure (lines 1181-1183)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
@@ -402,9 +412,11 @@ def test_sm_spin_up_activation_fail(mock_wallet):
 
 def test_sm_wind_down_no_service(mock_wallet):
     """Cover wind_down with no service (lines 1264-1266)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
@@ -415,9 +427,11 @@ def test_sm_wind_down_no_service(mock_wallet):
 
 def test_sm_wind_down_nonexistent(mock_wallet):
     """Cover wind_down with non-existent service (lines 1274-1276)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
@@ -432,9 +446,11 @@ def test_sm_wind_down_nonexistent(mock_wallet):
 
 def test_sm_mech_request_no_service(mock_wallet):
     """Cover _send_legacy_mech_request with no service (lines 1502-1504)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
@@ -445,9 +461,11 @@ def test_sm_mech_request_no_service(mock_wallet):
 
 def test_sm_mech_request_no_address(mock_wallet):
     """Cover _send_legacy_mech_request missing mech address (lines 1510-1512)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
-         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache,
+        patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache),
+    ):
         mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="unknown", service_id=1)
@@ -458,8 +476,10 @@ def test_sm_mech_request_no_address(mock_wallet):
 
 def test_sm_marketplace_mech_no_service(mock_wallet):
     """Cover _send_marketplace_mech_request with no service (lines 1549-1551)."""
-    with patch("iwa.core.models.Config"), \
-         patch("iwa.plugins.olas.service_manager.base.ContractCache"):
+    with (
+        patch("iwa.core.models.Config"),
+        patch("iwa.plugins.olas.service_manager.base.ContractCache"),
+    ):
         sm = ServiceManager(mock_wallet)
         sm.service = None