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

iwa/core/services/safe_executor.py

@@ -52,6 +52,7 @@ class SafeTransactionExecutor:
         config = Config().core
         self.max_retries = max_retries or config.safe_tx_max_retries
         self.gas_buffer = gas_buffer or config.safe_tx_gas_buffer
+        self._client_cache: Dict[str, EthereumClient] = {}
 
     def execute_with_retry(
         self,
@@ -81,17 +82,27 @@ class SafeTransactionExecutor:
             try:
                 # Prepare and execute attempt
                 tx_hash = self._execute_attempt(
-                    safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+                    safe_address,
+                    safe_tx,
+                    signer_keys,
+                    operation_name,
+                    attempt,
+                    current_gas,
+                    base_estimate,
                 )
 
                 # Check receipt
                 receipt = self.chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
                 if self._check_receipt_status(receipt):
                     SAFE_TX_STATS["final_successes"] += 1
-                    logger.info(f"[{operation_name}] Success on attempt {attempt + 1}. Tx Hash: {tx_hash}")
+                    logger.info(
+                        f"[{operation_name}] Success on attempt {attempt + 1}. Tx Hash: {tx_hash}"
+                    )
                     return True, tx_hash, receipt
 
-                logger.error(f"[{operation_name}] Mined but failed (status 0) on attempt {attempt + 1}.")
+                logger.error(
+                    f"[{operation_name}] Mined but failed (status 0) on attempt {attempt + 1}."
+                )
                 raise ValueError("Transaction reverted on-chain")
 
             except Exception as e:
@@ -112,7 +123,14 @@ class SafeTransactionExecutor:
         return False, str(last_error), None
 
     def _execute_attempt(
-        self, safe_address, safe_tx, signer_keys, operation_name, attempt, current_gas, base_estimate
+        self,
+        safe_address,
+        safe_tx,
+        signer_keys,
+        operation_name,
+        attempt,
+        current_gas,
+        base_estimate,
     ) -> str:
         """Prepare client, estimate gas, simulate, and execute."""
         # 1. (Re)Create Safe client
@@ -186,7 +204,12 @@ class SafeTransactionExecutor:
         return status == 1
 
     def _handle_execution_failure(
-        self, error: Exception, safe_address: str, safe_tx: SafeTx, attempt: int, operation_name: str
+        self,
+        error: Exception,
+        safe_address: str,
+        safe_tx: SafeTx,
+        attempt: int,
+        operation_name: str,
     ) -> Tuple[SafeTx, bool]:
         """Handle execution failure and determine next steps."""
         classification = self._classify_error(error)
@@ -220,7 +243,9 @@ class SafeTransactionExecutor:
         """Estimate gas for a Safe transaction with buffer and hard cap."""
         try:
             # Use on-chain simulation via safe-eth-py
-            estimated = safe.estimate_tx_gas(safe_tx.to, safe_tx.value, safe_tx.data, safe_tx.operation)
+            estimated = safe.estimate_tx_gas(
+                safe_tx.to, safe_tx.value, safe_tx.data, safe_tx.operation
+            )
             with_buffer = int(estimated * self.gas_buffer)
 
             # Apply x10 hard cap if we have a base estimate
@@ -237,16 +262,17 @@ class SafeTransactionExecutor:
 
     def _recreate_safe_client(self, safe_address: str) -> Safe:
         """Recreate Safe with current (possibly rotated) RPC."""
-        ethereum_client = EthereumClient(self.chain_interface.current_rpc)
+        rpc_url = self.chain_interface.current_rpc
+        if rpc_url not in self._client_cache:
+            self._client_cache[rpc_url] = EthereumClient(rpc_url)
+        ethereum_client = self._client_cache[rpc_url]
         return Safe(safe_address, ethereum_client)
 
     def _is_nonce_error(self, error: Exception) -> bool:
         """Check if error is due to Safe nonce conflict."""
         error_text = str(error).lower()
         # GS025 = Invalid nonce (NOT GS026 which is invalid signatures)
-        return any(x in error_text for x in [
-            "nonce", "gs025", "already executed", "duplicate"
-        ])
+        return any(x in error_text for x in ["nonce", "gs025", "already executed", "duplicate"])
 
     def _is_signature_error(self, error: Exception) -> bool:
         """Check if error is due to invalid Safe signatures.
@@ -257,10 +283,17 @@ class SafeTransactionExecutor:
         GS026 = Invalid owner (signature from non-owner)
         """
         error_text = str(error).lower()
-        return any(x in error_text for x in [
-            "gs020", "gs021", "gs024", "gs026",
-            "invalid signatures", "signatures data too short"
-        ])
+        return any(
+            x in error_text
+            for x in [
+                "gs020",
+                "gs021",
+                "gs024",
+                "gs026",
+                "invalid signatures",
+                "signatures data too short",
+            ]
+        )
 
     def _refresh_nonce(self, safe: Safe, safe_tx: SafeTx) -> SafeTx:
         """Re-fetch nonce and rebuild transaction."""
@@ -283,7 +316,9 @@ class SafeTransactionExecutor:
     def _classify_error(self, error: Exception) -> dict:
         """Classify Safe transaction errors for retry decisions."""
         err_text = str(error).lower()
-        is_rpc = self.chain_interface._is_rate_limit_error(error) or self.chain_interface._is_connection_error(error)
+        is_rpc = self.chain_interface._is_rate_limit_error(
+            error
+        ) or self.chain_interface._is_connection_error(error)
 
         return {
             "is_gas_error": any(x in err_text for x in ["gas", "out of gas", "intrinsic"]),
@@ -296,6 +331,7 @@ class SafeTransactionExecutor:
     def _decode_revert_reason(self, error: Exception) -> Optional[str]:
         """Attempt to decode the revert reason."""
         import re
+
         error_text = str(error)
         hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
         if hex_match:
@@ -311,6 +347,4 @@ class SafeTransactionExecutor:
 
     def _log_retry(self, attempt: int, error: Exception, strategy: str):
         """Log a retry attempt."""
-        logger.warning(
-            f"Safe TX attempt {attempt} failed, strategy: {strategy}. Error: {error}"
-        )
+        logger.warning(f"Safe TX attempt {attempt} failed, strategy: {strategy}. Error: {error}")

iwa/core/services/transaction.py

@@ -45,19 +45,29 @@ class TransferLogger:
         if tx_hash:
             try:
                 tx = self.chain_interface.web3.eth.get_transaction(tx_hash)
-                native_value = getattr(tx, "value", 0) or tx.get("value", 0) if isinstance(tx, dict) else getattr(tx, "value", 0)
+                native_value = (
+                    getattr(tx, "value", 0) or tx.get("value", 0)
+                    if isinstance(tx, dict)
+                    else getattr(tx, "value", 0)
+                )
                 if native_value and int(native_value) > 0:
-                    from_addr = getattr(tx, "from", "") if hasattr(tx, "from") else tx.get("from", "")
+                    from_addr = (
+                        getattr(tx, "from", "") if hasattr(tx, "from") else tx.get("from", "")
+                    )
                     # Handle AttributeDict's special 'from' attribute
                     if not from_addr and hasattr(tx, "__getitem__"):
                         from_addr = tx["from"]
-                    to_addr = getattr(tx, "to", "") or (tx.get("to", "") if isinstance(tx, dict) else "")
+                    to_addr = getattr(tx, "to", "") or (
+                        tx.get("to", "") if isinstance(tx, dict) else ""
+                    )
                     self._log_native_transfer(from_addr, to_addr, native_value)
             except Exception as e:
                 logger.debug(f"Could not get tx for native transfer logging: {e}")
 
         # Log ERC20 transfers from event logs
-        logs = receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        logs = (
+            receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        )
 
         for log in logs:
             self._process_log(log)
@@ -156,7 +166,9 @@ class TransferLogger:
         else:
             # Likely an NFT (ERC721) - the amount is the token ID
             if amount_wei > 0:
-                logger.info(f"[NFT TRANSFER] Token #{amount_wei} {token_label}: {from_label} → {to_label}")
+                logger.info(
+                    f"[NFT TRANSFER] Token #{amount_wei} {token_label}: {from_label} → {to_label}"
+                )
             else:
                 logger.debug(f"[NFT TRANSFER] {token_label}: {from_label} → {to_label}")
 
@@ -265,9 +277,7 @@ class TransactionService:
             """Inner operation wrapped by with_retry."""
             try:
                 signed_txn = self.key_storage.sign_transaction(tx, signer_address_or_tag)
-                txn_hash = chain_interface.web3.eth.send_raw_transaction(
-                    signed_txn.raw_transaction
-                )
+                txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
                 receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
 
                 status = getattr(receipt, "status", None)
@@ -412,10 +422,12 @@ class TransactionService:
         signer_account: StoredSafeAccount,
         chain_interface,
         chain_name: str,
-        tags: List[str] = None
+        tags: List[str] = None,
     ) -> Tuple[bool, Dict]:
         """Execute transaction via SafeService."""
-        logger.info(f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}...")
+        logger.info(
+            f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}..."
+        )
 
         try:
             # Extract basic params
@@ -431,7 +443,7 @@ class TransactionService:
                 to=to_addr,
                 value=value,
                 chain_name=chain_name,
-                data=data
+                data=data,
             )
 
             # Receipt is already waited for inside execute_safe_transaction/executor
@@ -445,7 +457,13 @@ class TransactionService:
             if receipt and status == 1:
                 logger.info(f"Safe transaction executed successfully. Tx Hash: {tx_hash}")
                 self._log_successful_transaction(
-                    receipt, tx, signer_account, chain_name, bytes.fromhex(tx_hash.replace("0x", "")), tags, chain_interface
+                    receipt,
+                    tx,
+                    signer_account,
+                    chain_name,
+                    bytes.fromhex(tx_hash.replace("0x", "")),
+                    tags,
+                    chain_interface,
                 )
                 return True, receipt
             else:
@@ -460,11 +478,13 @@ class TransactionService:
             # Extract hex data from common error patterns
             # Pattern 1: ('execution reverted', '0x...')
             import re
+
             hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
 
             if hex_match:
                 try:
                     from iwa.core.contracts.decoder import ErrorDecoder
+
                     data = hex_match.group(0)
                     decoded = ErrorDecoder().decode(data)
                     if decoded:

iwa/core/services/transfer/erc20.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from iwa.core.services.transfer import TransferService
 
 
-
 class ERC20TransferMixin:
     """Mixin for ERC20 token transfers and approvals."""
 

iwa/core/services/transfer/native.py

@@ -91,7 +91,7 @@ class NativeTransferMixin:
                 "from": from_account.address,
                 "to": to_address,
                 "value": amount_wei,
-            }
+            },
         )
 
         # Use unified TransactionService

iwa/core/tests/test_gnosis_fee.py

@@ -41,7 +41,9 @@ class TestGnosisFeeFix(unittest.TestCase):
 
         # CRITICAL ASSERTION: maxPriorityFeePerGas must be >= 1
         # If the fix works, it should be 1. If it fails (old behavior), it would be 0.
-        self.assertEqual(params["maxPriorityFeePerGas"], 1, "Priority fee should be forced to 1 wei")
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Priority fee should be forced to 1 wei"
+        )
 
         # Verify max fee calculation: (base * 1.5) + priority
         expected_max_fee = int(5000 * 1.5) + 1
@@ -84,4 +86,6 @@ class TestGnosisFeeFix(unittest.TestCase):
 
         params = eth_interface.calculate_transaction_params(mock_func, {"from": "0x123"})
 
-        self.assertEqual(params["maxPriorityFeePerGas"], 1, "Generic fallback should apply to all chains")
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Generic fallback should apply to all chains"
+        )

iwa/core/tests/test_ipfs.py

@@ -61,7 +61,7 @@ def test_push_to_ipfs_sync_uses_session(mock_config, mock_cid_decode):
 
         # Verify second call reuses session
         push_to_ipfs_sync(b"test data 2")
-        mock_session_cls.assert_called_once() # Should still be 1 call
+        mock_session_cls.assert_called_once()  # Should still be 1 call
         assert mock_session.post.call_count == 2
 
 

iwa/core/tests/test_regression_fixes.py

@@ -34,18 +34,14 @@ class TestRegressionFixes(unittest.TestCase):
         # This is what we are testing: get_suggested_fees() provides the safety net
         mock_chain_interface.get_suggested_fees.return_value = {
             "maxFeePerGas": 1500,
-            "maxPriorityFeePerGas": 10
+            "maxPriorityFeePerGas": 10,
         }
 
         with patch("iwa.core.services.transaction.ChainInterfaces") as mock_interfaces:
             mock_interfaces.return_value.get.return_value = mock_chain_interface
 
             # 3. Prepare transaction WITHOUT fees
-            tx = {
-                "to": "0x09312C66A14a024B4e903D986Ca7E2C0dDD06227",
-                "value": 1000,
-                "gas": 21000
-            }
+            tx = {"to": "0x09312C66A14a024B4e903D986Ca7E2C0dDD06227", "value": 1000, "gas": 21000}
 
             # 4. Run internal preparation
             service._prepare_transaction(tx, "signer", mock_chain_interface)
@@ -96,5 +92,6 @@ class TestRegressionFixes(unittest.TestCase):
                     self.assertIsInstance(accounts[key]["address"], str)
                     self.assertEqual(accounts[key]["address"].lower(), addr_str.lower())
 
+
 if __name__ == "__main__":
     unittest.main()

iwa/core/utils.py

@@ -85,9 +85,11 @@ def configure_logger():
     configure_logger.configured = True
     return logger
 
+
 def get_version(package_name: str) -> str:
     """Get package version."""
     from importlib.metadata import PackageNotFoundError, version
+
     try:
         return version(package_name)
     except PackageNotFoundError:

iwa/core/wallet.py

@@ -37,7 +37,9 @@ class Wallet:
         self.balance_service = BalanceService(self.key_storage, self.account_service)
         self.safe_service = SafeService(self.key_storage, self.account_service)
         # self.transaction_manager = TransactionManager(self.key_storage, self.account_service)
-        self.transaction_service = TransactionService(self.key_storage, self.account_service, self.safe_service)
+        self.transaction_service = TransactionService(
+            self.key_storage, self.account_service, self.safe_service
+        )
 
         self.transfer_service = TransferService(
             self.key_storage,

iwa/plugins/olas/constants.py

@@ -92,8 +92,12 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
 OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
     "gnosis": {
         # === LEGACY (no marketplace) ===
-        "Hobbyist 1 Legacy (100 OLAS)": EthereumAddress("0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"),
-        "Hobbyist 2 Legacy (500 OLAS)": EthereumAddress("0x238EB6993b90A978ec6AAD7530D6429c949C08DA"),
+        "Hobbyist 1 Legacy (100 OLAS)": EthereumAddress(
+            "0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"
+        ),
+        "Hobbyist 2 Legacy (500 OLAS)": EthereumAddress(
+            "0x238EB6993b90A978ec6AAD7530D6429c949C08DA"
+        ),
         "Expert Legacy (1k OLAS)": EthereumAddress("0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e"),
         "Expert 2 Legacy (1k OLAS)": EthereumAddress("0xb964e44c126410df341ae04B13aB10A985fE3513"),
         "Expert 3 Legacy (2k OLAS)": EthereumAddress("0x80faD33Cadb5F53f9D29F02Db97D682E8B101618"),
@@ -103,9 +107,15 @@ OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
         "Expert 7 Legacy (10k OLAS)": EthereumAddress("0xD7A3C8b975f71030135f1a66E9e23164d54fF455"),
         "Expert 8 Legacy (2k OLAS)": EthereumAddress("0x356C108D49C5eebd21c84c04E9162de41933030c"),
         "Expert 9 Legacy (10k OLAS)": EthereumAddress("0x17dBAe44BC5618Cc254055B386A29576b4F87015"),
-        "Expert 10 Legacy (10k OLAS)": EthereumAddress("0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"),
-        "Expert 11 Legacy (10k OLAS)": EthereumAddress("0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"),
-        "Expert 12 Legacy (10k OLAS)": EthereumAddress("0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"),
+        "Expert 10 Legacy (10k OLAS)": EthereumAddress(
+            "0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"
+        ),
+        "Expert 11 Legacy (10k OLAS)": EthereumAddress(
+            "0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"
+        ),
+        "Expert 12 Legacy (10k OLAS)": EthereumAddress(
+            "0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"
+        ),
         # === MM v1 (old marketplace 0x4554fE75...) ===
         "Expert 15 MM v1 (10k OLAS)": EthereumAddress("0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1"),
         "Expert 16 MM v1 (10k OLAS)": EthereumAddress("0x6c65430515c70a3f5E62107CC301685B7D46f991"),

iwa/plugins/olas/contracts/activity_checker.py

@@ -48,7 +48,6 @@ class ActivityCheckerContract(ContractInstance):
         self._agent_mech: Optional[EthereumAddress] = None
         self._liveness_ratio: Optional[int] = None
 
-
     def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
         """Get the nonces for a multisig address.
 
@@ -64,7 +63,6 @@ class ActivityCheckerContract(ContractInstance):
         nonces = self.contract.functions.getMultisigNonces(multisig).call()
         return (nonces[0], nonces[1])
 
-
     @property
     def mech_marketplace(self) -> Optional[EthereumAddress]:
         """Get the mech marketplace address."""
@@ -83,7 +81,9 @@ class ActivityCheckerContract(ContractInstance):
             try:
                 agent_mech_function = getattr(self.contract.functions, "agentMech", None)
                 self._agent_mech = (
-                    agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
+                    agent_mech_function().call()
+                    if agent_mech_function
+                    else DEFAULT_MECH_CONTRACT_ADDRESS
                 )
             except Exception:
                 self._agent_mech = DEFAULT_MECH_CONTRACT_ADDRESS

iwa/plugins/olas/contracts/staking.py

@@ -82,7 +82,6 @@ class StakingContract(ContractInstance):
         self._activity_checker: Optional[ActivityCheckerContract] = None
         self._activity_checker_address: Optional[EthereumAddress] = None
 
-
     def get_requirements(self) -> Dict[str, Union[str, int]]:
         """Get the contract requirements for token and deposits.
 

iwa/plugins/olas/events.py

@@ -1,6 +1,5 @@
 """Event-based cache invalidation for Olas contracts."""
 
-
 from loguru import logger
 
 from iwa.core.contracts.cache import ContractCache
@@ -75,7 +74,7 @@ class OlasEventInvalidator:
             except Exception as e:
                 logger.error(f"Error in OlasEventInvalidator: {e}")
 
-            time.sleep(10) # check every 10 seconds
+            time.sleep(10)  # check every 10 seconds
 
     def _check_events(self, from_block: int, to_block: int):
         """Check for relevant events in the block range."""
@@ -101,14 +100,19 @@ class OlasEventInvalidator:
                 StakingContract, self.staking_addresses[0], self.chain_name
             )
 
-
-            logs = self.web3.eth.get_logs({
-                "fromBlock": from_block,
-                "toBlock": to_block,
-                "address": self.staking_addresses,
-                "topics": [self.web3.keccak(text="Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)").hex()]
-                # Note: signature might vary, safer to use the event object if ABI allows
-            })
+            logs = self.web3.eth.get_logs(
+                {
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "address": self.staking_addresses,
+                    "topics": [
+                        self.web3.keccak(
+                            text="Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)"
+                        ).hex()
+                    ],
+                    # Note: signature might vary, safer to use the event object if ABI allows
+                }
+            )
 
             # If we used the contract event object to filter, it handles the topic generation:
             # logs = checkpoint_event_abi.get_logs(fromBlock=from_block, toBlock=to_block)
@@ -130,9 +134,7 @@ class OlasEventInvalidator:
                 # self.contract_cache.invalidate(StakingContract, addr, self.chain_name)
 
                 # Option B: Get instance and clear specific cache (safe public access)
-                instance = self.contract_cache.get_if_cached(
-                    StakingContract, addr, self.chain_name
-                )
+                instance = self.contract_cache.get_if_cached(StakingContract, addr, self.chain_name)
                 if instance:
                     instance.clear_epoch_cache()
                     logger.debug(f"Cleared epoch cache for {addr}")

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="multisig", # 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_multisig", # 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."""
@@ -926,7 +931,7 @@ class OlasServiceImporter:
         address: str,
         signers: List[str] = None,
         tag_suffix: str = "multisig",
-        service_name: Optional[str] = None
+        service_name: Optional[str] = None,
     ) -> Tuple[bool, str]:
         """Import a generic Safe."""
         if not address:
@@ -1062,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/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

@@ -135,9 +135,7 @@ class DrainManagerMixin:
         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}"
-        )
+        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(