iwa 0.0.21__py3-none-any.whl → 0.0.24__py3-none-any.whl

iwa/plugins/olas/importer.py

@@ -7,6 +7,7 @@ Supports two formats:
 """
 
 import json
+import re
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -17,6 +18,28 @@ from loguru import logger
 from iwa.core.keys import EncryptedAccount, KeyStorage
 from iwa.core.models import Config, StoredSafeAccount
 
+# Known mappings from olas-operate-middleware staking programs
+# See: https://github.com/valory-xyz/olas-operate-middleware/blob/main/operate/ledger/profiles.py
+STAKING_PROGRAM_MAP = {
+    # Pearl staking programs (gnosis) - operate format
+    "pearl_alpha": "0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e",  # Expert Legacy
+    "pearl_beta": "0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C",  # Hobbyist 1 Legacy
+    "pearl_beta_2": "0xE56dF1E563De1B10715cB313D514af350D207212",  # Expert 5 Legacy
+    "pearl_beta_3": "0xD7A3C8b975f71030135f1a66E9e23164d54fF455",  # Expert 7 Legacy
+    "pearl_beta_4": "0x17dBAe44BC5618Cc254055B386A29576b4F87015",  # Expert 9 Legacy
+    "pearl_beta_5": "0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f",  # Expert 10 Legacy
+    "pearl_beta_mm_v2_1": "0x75eeca6207be98cac3fde8a20ecd7b01e50b3472",  # Expert 3 MM v2
+    "pearl_beta_mm_v2_2": "0x9c7f6103e3a72e4d1805b9c683ea5b370ec1a99f",  # Expert 4 MM v2
+    "pearl_beta_mm_v2_3": "0xcdC603e0Ee55Aae92519f9770f214b2Be4967f7d",  # Expert 5 MM v2
+    # Quickstart staking programs (gnosis) - quickstart format
+    "quickstart_beta_expert_4": "0xaD9d891134443B443D7F30013c7e14Fe27F2E029",  # Expert 4 Legacy
+    "quickstart_beta_expert_7": "0xD7A3C8b975f71030135f1a66E9e23164d54fF455",  # Expert 7 Legacy
+    "quickstart_beta_expert_9": "0x17dBAe44BC5618Cc254055B386A29576b4F87015",  # Expert 9 Legacy
+    "quickstart_beta_expert_11": "0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7",  # Expert 11 Legacy
+    "quickstart_beta_expert_16_mech_marketplace": "0x6c65430515c70a3f5E62107CC301685B7D46f991",  # Expert 16 MM v1
+    "quickstart_beta_expert_18_mech_marketplace": "0x041e679d04Fc0D4f75Eb937Dea729Df09a58e454",  # Expert 18 MM v1
+}
+
 
 @dataclass
 class DiscoveredKey:
@@ -26,8 +49,10 @@ class DiscoveredKey:
     private_key: Optional[str] = None  # Plaintext hex (None if still encrypted)
     encrypted_keystore: Optional[dict] = None  # Web3 v3 keystore format
     source_file: Path = field(default_factory=Path)
-    role: str = "unknown"  # "agent", "operator", "owner"
+    role: str = "unknown"  # "agent", "owner"
     is_encrypted: bool = False
+    signature_verified: bool = False
+    signature_failed: bool = False
 
     @property
     def is_decrypted(self) -> bool:
@@ -55,6 +80,9 @@ class DiscoveredService:
     source_folder: Path = field(default_factory=Path)
     format: str = "unknown"  # "trader_runner" or "operate"
     service_name: Optional[str] = None
+    # New fields for full service import
+    staking_contract_address: Optional[str] = None
+    service_owner_address: Optional[str] = None
 
     @property
     def agent_key(self) -> Optional[DiscoveredKey]:
@@ -66,9 +94,14 @@ class DiscoveredService:
 
     @property
     def operator_key(self) -> Optional[DiscoveredKey]:
-        """Get the operator key if present."""
+        """Get the operator (owner) key. Alias for compatibility."""
+        return self.owner_key
+
+    @property
+    def owner_key(self) -> Optional[DiscoveredKey]:
+        """Get the owner key if present (matches 'owner' or 'operator' roles)."""
         for key in self.keys:
-            if key.role in ("operator", "owner"):
+            if key.role in ["owner", "operator"]:
                 return key
         return None
 
@@ -89,15 +122,17 @@ class ImportResult:
 class OlasServiceImporter:
     """Discover and import Olas services from external directories."""
 
-    def __init__(self, key_storage: Optional[KeyStorage] = None):
+    def __init__(self, key_storage: Optional[KeyStorage] = None, password: Optional[str] = None):
         """Initialize the importer.
 
         Args:
             key_storage: KeyStorage instance. If None, will create one.
+            password: Optional password to decrypt discovered keystores.
 
         """
         self.key_storage = key_storage or KeyStorage()
         self.config = Config()
+        self.password = password
 
     def scan_directory(self, path: Path) -> List[DiscoveredService]:
         """Recursively scan a directory for Olas services.
@@ -106,7 +141,7 @@ class OlasServiceImporter:
             path: Directory to scan.
 
         Returns:
-            List of discovered services.
+            List of discovered services (deduplicated by chain:service_id).
 
         """
         path = Path(path)
@@ -129,8 +164,51 @@ class OlasServiceImporter:
                 services = self._parse_operate_format(operate)
                 discovered.extend(services)
 
-        logger.info(f"Discovered {len(discovered)} Olas service(s)")
-        return discovered
+        return self._deduplicate_services(discovered)
+
+    def _deduplicate_services(self, services: List[DiscoveredService]) -> List[DiscoveredService]:
+        """Deduplicate discovered services by chain:service_id."""
+        seen_keys: set = set()
+        unique_services = []
+        duplicates = 0
+        for service in services:
+            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}"
+                    )
+                    duplicates += 1
+                    continue
+                seen_keys.add(key)
+            unique_services.append(service)
+
+        if duplicates:
+            logger.info(f"Skipped {duplicates} duplicate service(s)")
+        logger.info(f"Discovered {len(unique_services)} unique Olas service(s)")
+        return unique_services
+
+    def _find_trader_name(self, folder: Path) -> str:
+        """Find the trader name by traversing up the directory tree.
+
+        Handles quickstart format where the .operate folder is nested inside
+        a quickstart folder, e.g.: trader_altair/quickstart/.operate/
+
+        Returns the first folder name starting with 'trader_' or the
+        immediate folder name if none found.
+        """
+        current = folder
+        fallback = folder.name
+
+        # Traverse up looking for trader_* folder
+        for _ in range(5):  # Max 5 levels up
+            if current.name.startswith("trader_"):
+                return current.name
+            current = current.parent
+            if current == current.parent:  # Reached root
+                break
+
+        return fallback
 
     def _parse_trader_runner_format(self, folder: Path) -> Optional[DiscoveredService]:
         """Parse a .trader_runner folder.
@@ -153,6 +231,9 @@ class OlasServiceImporter:
         service.safe_address = self._extract_safe_address(folder)
         service.keys = self._extract_trader_keys(folder)
 
+        # Extract staking program from .env
+        self._extract_staking_from_env(service, folder)
+
         if not service.keys and not service.service_id:
             logger.debug(f"No valid data found in {folder}")
             return None
@@ -187,10 +268,10 @@ class OlasServiceImporter:
             if key:
                 keys.append(key)
 
-        # Parse operator_pkey.txt
+        # Parse operator_pkey.txt (contains owner key)
         operator_file = folder / "operator_pkey.txt"
         if operator_file.exists():
-            key = self._parse_keystore_file(operator_file, role="operator")
+            key = self._parse_keystore_file(operator_file, role="owner")
             if key:
                 keys.append(key)
 
@@ -205,6 +286,31 @@ class OlasServiceImporter:
                     keys.append(key)
         return keys
 
+    def _extract_staking_from_env(self, service: DiscoveredService, folder: Path) -> None:
+        """Extract STAKING_PROGRAM from .env file in trader_runner folder."""
+        # Check parent folder for .env (usually alongside .trader_runner)
+        env_file = folder.parent / ".env"
+        if not env_file.exists():
+            # Also check inside the folder itself
+            env_file = folder / ".env"
+        if not env_file.exists():
+            return
+
+        try:
+            content = env_file.read_text()
+            for line in content.splitlines():
+                line = line.strip()
+                if line.startswith("STAKING_PROGRAM="):
+                    program_id = line.split("=", 1)[1].strip().strip('"').strip("'")
+                    if program_id:
+                        service.staking_contract_address = self._resolve_staking_contract(
+                            program_id, service.chain_name
+                        )
+                        logger.debug(f"Found STAKING_PROGRAM={program_id} in {env_file}")
+                    break
+        except IOError as e:
+            logger.warning(f"Failed to read {env_file}: {e}")
+
     def _parse_operate_format(self, folder: Path) -> List[DiscoveredService]:
         """Parse a .operate folder.
 
@@ -288,12 +394,15 @@ class OlasServiceImporter:
 
         # Use the folder name containing .operate (e.g., "trader_xi")
         operate_folder = config_file.parent.parent.parent  # services/<uuid> -> .operate
-        parent_folder = operate_folder.parent  # .operate -> trader_xi
+        parent_folder = operate_folder.parent  # .operate -> trader_xi or quickstart
+
+        # Handle quickstart format: traverse up to find trader_* folder
+        service_name = self._find_trader_name(parent_folder)
 
         service = DiscoveredService(
             source_folder=config_file.parent,
             format="operate",
-            service_name=parent_folder.name,
+            service_name=service_name,
         )
 
         # 1. Extract keys from config
@@ -311,6 +420,9 @@ class OlasServiceImporter:
         external_keys = self._extract_external_keys_folder(operate_folder)
         self._merge_unique_keys(service, external_keys)
 
+        # 5. Extract owner address from wallets folder
+        self._extract_owner_address(service, operate_folder)
+
         return service
 
     def _extract_keys_from_operate_config(
@@ -325,19 +437,19 @@ class OlasServiceImporter:
                     # Remove 0x prefix if present
                     if private_key.startswith("0x"):
                         private_key = private_key[2:]
-                    keys.append(
-                        DiscoveredKey(
-                            address=key_data["address"],
-                            private_key=private_key,
-                            role="agent",
-                            source_file=config_file,
-                            is_encrypted=False,
-                        )
+                    key = DiscoveredKey(
+                        address=key_data["address"],
+                        private_key=private_key,
+                        role="agent",
+                        source_file=config_file,
+                        is_encrypted=False,
                     )
+                    self._verify_key_signature(key)
+                    keys.append(key)
         return keys
 
     def _enrich_service_with_chain_info(self, service: DiscoveredService, data: dict) -> None:
-        """Extract service ID and Safe address from chain configs."""
+        """Extract service ID, Safe address, and staking contract from chain configs."""
         chain_configs = data.get("chain_configs", {})
         for chain_name, chain_config in chain_configs.items():
             chain_data = chain_config.get("chain_data", {})
@@ -350,6 +462,25 @@ class OlasServiceImporter:
             if "multisig" in chain_data:
                 service.safe_address = chain_data["multisig"]
 
+            # Extract staking contract from user_params
+            user_params = chain_data.get("user_params", {})
+            staking_program_id = user_params.get("staking_program_id")
+            if staking_program_id:
+                service.staking_contract_address = self._resolve_staking_contract(
+                    staking_program_id, chain_name
+                )
+
+    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:
+            logger.debug(f"Resolved staking program '{staking_program_id}' -> {address}")
+        else:
+            logger.warning(f"Unknown staking program ID: {staking_program_id}")
+        return address
+
     def _extract_parent_wallet_keys(self, operate_folder: Path) -> List[DiscoveredKey]:
         """Extract owner keys from parent wallets folder."""
         keys = []
@@ -357,7 +488,12 @@ class OlasServiceImporter:
         if wallets_folder.exists():
             eth_txt = wallets_folder / "ethereum.txt"
             if eth_txt.exists():
+                # Try plaintext first
                 key = self._parse_plaintext_key_file(eth_txt, role="owner")
+                if not key:
+                    # Fallback to keystore
+                    key = self._parse_keystore_file(eth_txt, role="owner")
+
                 if key:
                     keys.append(key)
         return keys
@@ -374,6 +510,22 @@ class OlasServiceImporter:
                         keys.append(key)
         return keys
 
+    def _extract_owner_address(self, service: DiscoveredService, operate_folder: Path) -> None:
+        """Extract owner address from wallets/ethereum.json."""
+        wallets_folder = operate_folder / "wallets"
+        if not wallets_folder.exists():
+            return
+
+        eth_json = wallets_folder / "ethereum.json"
+        if eth_json.exists():
+            try:
+                data = json.loads(eth_json.read_text())
+                if "address" in data:
+                    service.service_owner_address = data["address"]
+                    logger.debug(f"Extracted owner address: {service.service_owner_address}")
+            except (json.JSONDecodeError, IOError) as e:
+                logger.warning(f"Failed to parse {eth_json}: {e}")
+
     def _merge_unique_keys(self, service: DiscoveredService, new_keys: List[DiscoveredKey]):
         """Merge new keys into service avoiding duplicates by address."""
         existing_addrs = {k.address.lower() for k in service.keys}
@@ -398,13 +550,21 @@ class OlasServiceImporter:
             if not address.startswith("0x"):
                 address = "0x" + address
 
-            return DiscoveredKey(
+            key = DiscoveredKey(
                 address=address,
                 encrypted_keystore=keystore,
                 role=role,
                 source_file=file_path,
                 is_encrypted=True,
             )
+
+            # Attempt decryption if password provided
+            if self.password:
+                self._attempt_decryption(key)
+                if key.private_key:
+                    self._verify_key_signature(key)
+
+            return key
         except (json.JSONDecodeError, IOError) as e:
             logger.warning(f"Failed to parse keystore {file_path}: {e}")
             return None
@@ -422,15 +582,19 @@ class OlasServiceImporter:
                     address = keystore.get("address", "")
                     if not address.startswith("0x"):
                         address = "0x" + address
-                    keys.append(
-                        DiscoveredKey(
-                            address=address,
-                            encrypted_keystore=keystore,
-                            role="agent",
-                            source_file=file_path,
-                            is_encrypted=True,
-                        )
+                    key = DiscoveredKey(
+                        address=address,
+                        encrypted_keystore=keystore,
+                        role="agent",
+                        source_file=file_path,
+                        is_encrypted=True,
                     )
+                    # Attempt decryption if password provided
+                    if self.password:
+                        self._attempt_decryption(key)
+                        if key.private_key:
+                            self._verify_key_signature(key)
+                    keys.append(key)
             return keys
         except (json.JSONDecodeError, IOError):
             return []
@@ -446,13 +610,15 @@ class OlasServiceImporter:
             try:
                 data = json.loads(content)
                 if isinstance(data, dict) and "private_key" in data and "address" in data:
-                    return DiscoveredKey(
+                    key = DiscoveredKey(
                         address=data["address"],
                         private_key=data["private_key"],
                         role=role,
                         source_file=file_path,
                         is_encrypted=False,
                     )
+                    self._verify_key_signature(key)
+                    return key
             except json.JSONDecodeError:
                 pass
 
@@ -460,13 +626,15 @@ class OlasServiceImporter:
             if len(content) == 64 or (len(content) == 66 and content.startswith("0x")):
                 private_key = content[2:] if content.startswith("0x") else content
                 account = Account.from_key(bytes.fromhex(private_key))
-                return DiscoveredKey(
+                key = DiscoveredKey(
                     address=account.address,
                     private_key=private_key,
                     role=role,
                     source_file=file_path,
                     is_encrypted=False,
                 )
+                self._verify_key_signature(key)
+                return key
 
             return None
         except Exception as e:
@@ -625,8 +793,6 @@ class OlasServiceImporter:
         Tags follow the pattern: {service_name}_{role}
         Example: trader_alpha_agent, trader_alpha_operator
         """
-        import re
-
         # Use service name as prefix, or 'imported' as fallback
         prefix = service_name or "imported"
 
@@ -667,7 +833,6 @@ class OlasServiceImporter:
                 signers.append(key.address)
 
         # Generate tag
-        import re
 
         prefix = service.service_name or "imported"
         prefix = re.sub(r"[^a-z0-9]+", "_", prefix.lower()).strip("_")
@@ -698,6 +863,7 @@ class OlasServiceImporter:
     def _import_service_config(self, service: DiscoveredService) -> Tuple[bool, str]:
         """Import service config to OlasConfig."""
         try:
+            from iwa.plugins.olas.constants import OLAS_TOKEN_ADDRESS_GNOSIS
             from iwa.plugins.olas.models import OlasConfig, Service
 
             # Get or create OlasConfig
@@ -711,13 +877,16 @@ class OlasServiceImporter:
             if key in olas_config.services:
                 return False, "duplicate"
 
-            # Create service model
+            # Create service model with all fields
             olas_service = Service(
                 service_name=service.service_name or f"service_{service.service_id}",
                 chain_name=service.chain_name,
                 service_id=service.service_id,
-                agent_ids=[],  # Would need on-chain query
+                agent_ids=[25],  # Trader agents always use agent ID 25
                 multisig_address=service.safe_address,
+                service_owner_address=service.service_owner_address,
+                staking_contract_address=service.staking_contract_address,
+                token_address=str(OLAS_TOKEN_ADDRESS_GNOSIS),
             )
 
             # Set agent address if we have one
@@ -726,7 +895,7 @@ class OlasServiceImporter:
                 olas_service.agent_address = agent_key.address
 
             olas_config.add_service(olas_service)
-            self.config.save()
+            self.config.save_config()
             logger.info(f"Imported service {key}")
             return True, "ok"
 
@@ -734,3 +903,58 @@ class OlasServiceImporter:
             return False, "Olas plugin not available"
         except Exception as e:
             return False, str(e)
+
+    def _attempt_decryption(self, key: DiscoveredKey) -> None:
+        """Attempt to decrypt an encrypted keystore using the provided password."""
+        if not self.password or not key.encrypted_keystore:
+            return
+
+        try:
+            logger.debug(f"Attempting decryption for {key.address}")
+
+            # Use Account.decrypt to handle standard web3 keystores
+            private_key_bytes = Account.decrypt(key.encrypted_keystore, self.password)
+            key.private_key = private_key_bytes.hex()
+            key.is_encrypted = False
+            # If we successfully decrypted, it's no longer "encrypted" for verification purposes
+            logger.debug(f"Successfully decrypted key for {key.address}")
+        except ValueError as e:
+            # Password incorrect
+            logger.warning(f"Decryption failed (ValueError) for {key.address}: {e}")
+        except Exception as e:
+            logger.warning(f"Error decrypting key {key.address}: {type(e).__name__} - {e}")
+
+    def _verify_key_signature(self, key: DiscoveredKey) -> None:
+        """Verify that the plaintext private key can sign a message and recover the address."""
+        if not key.private_key or not key.address:
+            return
+
+        try:
+            from eth_account.messages import encode_defunct
+
+            message = "Hello, world!"
+            encoded_message = encode_defunct(text=message)
+            signed_message = Account.sign_message(encoded_message, private_key=key.private_key)
+            recovered_address = Account.recover_message(
+                encoded_message, signature=signed_message.signature
+            )
+
+            # Normalize address to lowercase with 0x prefix
+            key_addr = key.address.lower()
+            if not key_addr.startswith("0x"):
+                key_addr = "0x" + key_addr
+            recovered_addr = recovered_address.lower()
+
+            if recovered_addr == key_addr:
+                key.signature_verified = True
+                logger.debug(f"Signature verified for key {key.address}")
+            else:
+                key.signature_failed = True
+                logger.warning(
+                    f"Signature verification FAILED for key {key.address}. "
+                    f"Recovered: {recovered_address}"
+                )
+        except Exception as e:
+            key.signature_failed = True
+            logger.warning(f"Error verifying signature for key {key.address}: {e}")
+

iwa/plugins/olas/plugin.py

@@ -1,10 +1,11 @@
 """Olas plugin."""
 
 from pathlib import Path
-from typing import Dict, Optional, Type
+from typing import Dict, List, Optional, Tuple, Type
 
 import typer
 from pydantic import BaseModel
+from rich.console import Console
 
 from iwa.core.plugins import Plugin
 from iwa.core.wallet import Wallet
@@ -86,7 +87,18 @@ class OlasPlugin(Plugin):
             # Query failed - Safe likely doesn't exist
             return [], False
 
-    def _display_service_table(self, console, service, index: int) -> None:
+    def _resolve_staking_name(self, address: str, chain_name: str) -> str | None:
+        """Resolve staking contract address to human-readable name."""
+        from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
+
+        chain_contracts = OLAS_TRADER_STAKING_CONTRACTS.get(chain_name, {})
+        addr_lower = address.lower()
+        for name, contract_addr in chain_contracts.items():
+            if str(contract_addr).lower() == addr_lower:
+                return name
+        return None
+
+    def _display_service_table(self, console: Console, service, index: int) -> None:
         """Display a single discovered service as a Rich table."""
         from rich.table import Table
 
@@ -98,46 +110,102 @@ class OlasPlugin(Plugin):
 
         table.add_row("Format", service.format)
         table.add_row("Source", str(service.source_folder))
-        table.add_row("Service ID", str(service.service_id) if service.service_id else "N/A")
+        table.add_row(
+            "Service ID",
+            str(service.service_id) if service.service_id else "[red]Not detected[/red]",
+        )
         table.add_row("Chain", service.chain_name)
 
         # Verify Safe and display
+        on_chain_signers, safe_exists = self._add_safe_info(table, service)
+
+        # Display staking contract info
+        self._add_staking_info(table, service)
+
+        # Display owner
+        self._add_owner_info(table, service)
+
+        # Display agent key
+        self._add_agent_info(table, service, on_chain_signers, safe_exists)
+
+        console.print(table)
+        console.print()
+
+    def _add_safe_info(self, table, service) -> Tuple[Optional[List[str]], Optional[bool]]:
+        """Add Safe information to the display table."""
         on_chain_signers, safe_exists = None, None
         if service.safe_address:
             on_chain_signers, safe_exists = self._get_safe_signers(
                 service.safe_address, service.chain_name
             )
-            if safe_exists is None:
-                table.add_row("Safe", service.safe_address)
-            elif safe_exists:
-                table.add_row("Safe", f"{service.safe_address} [green]✓[/green]")
-            else:
-                table.add_row(
-                    "Safe",
-                    f"[bold red]⚠ {service.safe_address} - DOES NOT EXIST ON-CHAIN![/bold red]",
+            safe_text = service.safe_address
+            if safe_exists:
+                safe_text += " [green]✓[/green]"
+            elif safe_exists is False:
+                safe_text = (
+                    f"[bold red]⚠ {service.safe_address} - DOES NOT EXIST ON-CHAIN![/bold red]"
                 )
+            table.add_row("Multisig", safe_text)
         else:
-            table.add_row("Safe", "N/A")
-
-        # Display keys with signer verification
-        for key in service.keys:
-            status = "🔒 encrypted" if key.is_encrypted else "🔓 plaintext"
-            key_info = f"{key.address} {status}"
-
-            if key.role == "agent" and service.safe_address:
-                if not safe_exists:
-                    key_info = f"[bold red]⚠ {key.address} - NOT A SIGNER OF THE SAFE![/bold red]"
+            table.add_row("Multisig", "[red]Not detected[/red]")
+        return on_chain_signers, safe_exists
+
+    def _add_staking_info(self, table, service) -> None:
+        """Add staking information to the display table."""
+        if service.staking_contract_address:
+            staking_name = self._resolve_staking_name(
+                service.staking_contract_address, service.chain_name
+            )
+            val = staking_name if staking_name else "[red]Unknown[/red]"
+            table.add_row("Staking", val)
+            table.add_row("Staking Addr", service.staking_contract_address)
+        else:
+            table.add_row("Staking", "[red]Not detected[/red]")
+            table.add_row("Staking Addr", "[red]Not detected[/red]")
+
+    def _add_owner_info(self, table, service) -> None:
+        """Add owner information to the display table."""
+        owner_key = next((k for k in service.keys if k.role == "owner"), None)
+        owner_addr = service.service_owner_address
+        if not owner_addr and owner_key:
+            owner_addr = owner_key.address
+
+        if owner_addr:
+            val = owner_addr
+            if owner_key:
+                if owner_key.signature_verified:
+                    val = f"[green]{owner_addr}[/green]"
+                elif not owner_key.is_encrypted:
+                    val = f"[red]{owner_addr}[/red]"
+                status = "🔒 encrypted" if owner_key.is_encrypted else "🔓 plaintext"
+                table.add_row("Owner", f"{val} {status}")
+            else:
+                table.add_row("Owner", val)
+        else:
+            table.add_row("Owner", "[red]Not detected[/red]")
+
+    def _add_agent_info(self, table, service, on_chain_signers, safe_exists) -> None:
+        """Add agent information to the display table."""
+        agent_key = next((k for k in service.keys if k.role == "agent"), None)
+        if agent_key:
+            status = "🔒 encrypted" if agent_key.is_encrypted else "🔓 plaintext"
+            addr_val = agent_key.address
+            if agent_key.signature_verified:
+                addr_val = f"[green]{agent_key.address}[/green]"
+            elif not agent_key.is_encrypted:
+                addr_val = f"[red]{agent_key.address}[/red]"
+
+            key_info = f"{addr_val} {status}"
+            if service.safe_address:
+                if safe_exists is False:
+                    key_info = f"[bold red]⚠ {agent_key.address} - NOT A SIGNER![/bold red]"
                 elif on_chain_signers is not None:
-                    is_signer = key.address.lower() in [s.lower() for s in on_chain_signers]
+                    is_signer = agent_key.address.lower() in [s.lower() for s in on_chain_signers]
                     if not is_signer:
-                        key_info = (
-                            f"[bold red]⚠ {key.address} - NOT A SIGNER OF THE SAFE![/bold red]"
-                        )
-
-            table.add_row(f"Key ({key.role})", key_info)
-
-        console.print(table)
-        console.print()
+                        key_info = f"[bold red]⚠ {agent_key.address} - NOT A SIGNER![/bold red]"
+            table.add_row("Agent", key_info)
+        else:
+            table.add_row("Agent", "[red]Not detected[/red]")
 
     def _import_and_print_results(self, console, importer, discovered, password) -> tuple:
         """Import all discovered services and print results."""
@@ -194,15 +262,18 @@ class OlasPlugin(Plugin):
         ),
     ):
         """Import Olas services and keys from external directories."""
-        from rich.console import Console
-
         from iwa.plugins.olas.importer import OlasServiceImporter
 
         console = Console()
 
         # Scan directory
         console.print(f"\n[bold]Scanning[/bold] {path}...")
-        importer = OlasServiceImporter()
+
+        # Ask for password in dry-run to allow signature verification of encrypted keys
+        if dry_run and not password:
+            password = self._prompt_dry_run_password()
+
+        importer = OlasServiceImporter(password=password)
         discovered = importer.scan_directory(Path(path))
 
         if not discovered:
@@ -219,11 +290,9 @@ class OlasPlugin(Plugin):
             raise typer.Exit(code=0)
 
         # Confirm import
-        if not yes:
-            confirm = typer.confirm("Import these services?")
-            if not confirm:
-                console.print("[yellow]Aborted.[/yellow]")
-                raise typer.Exit(code=0)
+        if not yes and not typer.confirm("Import these services?"):
+            console.print("[yellow]Aborted.[/yellow]")
+            raise typer.Exit(code=0)
 
         # Check if we need a password for encrypted keys
         needs_password = any(key.is_encrypted for service in discovered for key in service.keys)
@@ -234,11 +303,28 @@ class OlasPlugin(Plugin):
             password = typer.prompt("Password", hide_input=True)
 
         # Import services
-        total_keys, total_safes, total_services, all_skipped, all_errors = (
-            self._import_and_print_results(console, importer, discovered, password)
+        results = self._import_and_print_results(console, importer, discovered, password)
+        self._print_import_summary(console, *results)
+
+    def _prompt_dry_run_password(self) -> Optional[str]:
+        """Prompt for password during dry-run."""
+        pwd = typer.prompt(
+            "Enter wallet password to verify encrypted keys (optional, press Enter to skip)",
+            hide_input=True,
+            default="",
         )
+        return pwd if pwd else None
 
-        # Summary
+    def _print_import_summary(
+        self,
+        console: Console,
+        total_keys: int,
+        total_safes: int,
+        total_services: int,
+        all_skipped: List[str],
+        all_errors: List[str],
+    ) -> None:
+        """Print import summary."""
         console.print("\n[bold]Summary:[/bold]")
         console.print(f"  Keys imported: {total_keys}")
         console.print(f"  Safes imported: {total_safes}")

iwa/plugins/olas/tests/test_importer_error_handling.py

@@ -161,7 +161,7 @@ def test_parse_trader_runner_keys(importer, tmp_path):
     assert service.safe_address == "0xSafeAddress"
     assert len(service.keys) == 2
     assert any(k.role == "agent" for k in service.keys)
-    assert any(k.role == "operator" for k in service.keys)
+    assert any(k.role == "owner" for k in service.keys)
 
 
 def test_parse_trader_runner_invalid_id(importer, tmp_path):

iwa/plugins/olas/tests/test_plugin_full.py

@@ -68,7 +68,7 @@ def test_import_services_cli_scan_only(plugin, runner):
         ]
 
         # Test dry-run
-        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"], input="\n")
         assert result.exit_code == 0
         assert "Found 1 service(s)" in result.output
         assert "Dry run mode" in result.output
@@ -185,15 +185,15 @@ def test_import_services_cli_complex_display(plugin, runner):
         # Mock Safe exists with Agent as signer
         mock_get_signers.return_value = (["0xAgent"], True)
 
-        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"], input="\n")
         assert "0xSafe" in result.output
         assert "✓" in result.output
         assert "0xAgent 🔓 plaintext" in result.output  # Not a warning
 
         # 2. Service where agent is NOT a signer
         mock_get_signers.return_value = (["0xOther"], True)
-        result = runner.invoke(app, ["/tmp/test", "--dry-run"])
-        assert "NOT A SIGNER OF THE SAFE" in result.output
+        result = runner.invoke(app, ["/tmp/test", "--dry-run"], input="\n")
+        assert "NOT A SIGNER!" in result.output
 
 
 def test_import_services_cli_password_prompt(plugin, runner):

{iwa-0.0.21.dist-info → iwa-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.21
+Version: 0.0.24
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown

{iwa-0.0.21.dist-info → iwa-0.0.24.dist-info}/RECORD

@@ -61,10 +61,10 @@ iwa/plugins/gnosis/tests/test_safe.py,sha256=hQHVHBWQhGnuvzvx4U9fOWEwASJWwql42q6
 iwa/plugins/olas/__init__.py,sha256=_NhBczzM61fhGYwGhnWfEeL8Jywyy_730GASe2BxzeQ,106
 iwa/plugins/olas/constants.py,sha256=iTFoO2QW3KbhL5k5sKsJxxyDytl9wVIb_9hAih55KrE,7728
 iwa/plugins/olas/events.py,sha256=SWD3wYdQ-l6dLUJSkfh_WsLmedH4Vsw_EvYXg7QC3yc,5970
-iwa/plugins/olas/importer.py,sha256=f8KlZ9dGcNbpg8uoTYbO9sDvbluZoslhpWFLqPjPnLA,26717
+iwa/plugins/olas/importer.py,sha256=-zI0Fqmf6E7w3OpqEuTR8vuQOaAGNykGWzHZgadrHmE,37362
 iwa/plugins/olas/mech_reference.py,sha256=CaSCpQnQL4F7wOG6Ox6Zdoy-uNEQ78YBwVLILQZKL8Q,5782
 iwa/plugins/olas/models.py,sha256=xC5hYakX53pBT6zZteM9cyiC7t6XRLLpobjQmDYueOo,3520
-iwa/plugins/olas/plugin.py,sha256=h7Wjw-ozalu9ocZbFcQGEw_TM8fgW6Qyh_DY1VOGeLY,9393
+iwa/plugins/olas/plugin.py,sha256=sv1Hx4-wHZOwpdjhrpvxrFaA44wiGkcCXjbI_7NLH2Y,13127
 iwa/plugins/olas/contracts/activity_checker.py,sha256=WXxuzbpXGVqIfEiMPiiqN3Z_UxIY-Lvx0raa1ErBfPA,5323
 iwa/plugins/olas/contracts/base.py,sha256=y73aQbDq6l4zUpz_eQAg4MsLkTAEqjjupXlcvxjfgCI,240
 iwa/plugins/olas/contracts/mech.py,sha256=dXYtyORc-oiu9ga5PtTquOFkoakb6BLGKvlUsteygIg,2767
@@ -92,7 +92,7 @@ iwa/plugins/olas/service_manager/mech.py,sha256=NVzVbEmyOe3wK92VEzCCOSuy3HDkEP1M
 iwa/plugins/olas/service_manager/staking.py,sha256=7REp_HziKtqF9uSvbcq01C9XiaxgVT3gCimuLAAdNnM,28219
 iwa/plugins/olas/tests/conftest.py,sha256=4vM7EI00SrTGyeP0hNzsGSQHEj2-iznVgzlNh2_OGfo,739
 iwa/plugins/olas/tests/test_importer.py,sha256=i9LKov7kNRECB3hmRnhKBwcfx3uxtjWe4BB77bOOpeo,4282
-iwa/plugins/olas/tests/test_importer_error_handling.py,sha256=X37TrvJ6-3-NuJ2megm0Cnx3KJdA1wke563pRf_EPJk,12084
+iwa/plugins/olas/tests/test_importer_error_handling.py,sha256=O5yd7w_eURtkJb8_IwAGkz8fyHLTzYfI5c2JxWl3oOo,12081
 iwa/plugins/olas/tests/test_mech_contracts.py,sha256=wvxuigPafF-ySIHVBdWVei3AO418iPh7cSVdAlUGm_s,3566
 iwa/plugins/olas/tests/test_olas_contracts.py,sha256=B8X-5l1KfYMoZOiM94_rcNzbILLl78rqt_jhyxzAOqE,10835
 iwa/plugins/olas/tests/test_olas_integration.py,sha256=vjL8-RNdxXu6RFR5F1Bn7xqnxnUVWTzl2--Pp7-0r5A,22973
@@ -101,7 +101,7 @@ iwa/plugins/olas/tests/test_olas_view.py,sha256=kh3crsriyoRiZC6l8vzGllocvQnYmqzi
 iwa/plugins/olas/tests/test_olas_view_actions.py,sha256=jAxr9bjFNAaxGf1btIrxdMaHgJ0PWX9aDwVU-oPGMpk,5109
 iwa/plugins/olas/tests/test_olas_view_modals.py,sha256=8j0PNFjKqFC5V1kBdVFWNLMvqGt49H6fLSYGxn02c8o,5562
 iwa/plugins/olas/tests/test_plugin.py,sha256=RVgU-Cq6t_3mOh90xFAGwlJOV7ZIgp0VNaK5ZAxisAQ,2565
-iwa/plugins/olas/tests/test_plugin_full.py,sha256=HdEJf_beqH18TaA-PFFMsKFA4ycXY-bz_kbaHQknaic,8390
+iwa/plugins/olas/tests/test_plugin_full.py,sha256=GBZ-TL5t8NXy6HVQozCI1hMEn2EY4lXjGFC89QpoPxQ,8415
 iwa/plugins/olas/tests/test_service_lifecycle.py,sha256=sOCtpz8T9s55AZe9AoqP1h3XrXw5NDSjDqwLgYThvU4,5559
 iwa/plugins/olas/tests/test_service_manager.py,sha256=rS2m0A26apc-o4HsfP5oXmVcmZSR5e874bjhQKZRaSg,40650
 iwa/plugins/olas/tests/test_service_manager_errors.py,sha256=udlAsQj_t1F5TwVQuWhroF6jDJ4RmGEXaxPh87tMsuA,8538
@@ -157,7 +157,7 @@ iwa/web/tests/test_web_endpoints.py,sha256=C264MH-CTyDW4GLUrTXBgLJKUk4-89pFAScBd
 iwa/web/tests/test_web_olas.py,sha256=0CVSsrncOeJ3x0ECV7mVLQV_CXZRrOqGiVjgLIi6hZ8,16308
 iwa/web/tests/test_web_swap.py,sha256=7A4gBJFL01kIXPtW1E1J17SCsVc_0DmUn-R8kKrnnVA,2974
 iwa/web/tests/test_web_swap_coverage.py,sha256=zGNrzlhZ_vWDCvWmLcoUwFgqxnrp_ACbo49AtWBS_Kw,5584
-iwa-0.0.21.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.0.24.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
 tests/legacy_cow.py,sha256=oOkZvIxL70ReEoD9oHQbOD5GpjIr6AGNHcOCgfPlerU,8389
 tests/legacy_safe.py,sha256=AssM2g13E74dNGODu_H0Q0y412lgqsrYnEzI97nm_Ts,2972
 tests/legacy_transaction_retry_logic.py,sha256=D9RqZ7DBu61Xr2djBAodU2p9UE939LL-DnQXswX5iQk,1497
@@ -210,8 +210,8 @@ tests/test_utils.py,sha256=vkP49rYNI8BRzLpWR3WnKdDr8upeZjZcs7Rx0pjbQMo,1292
 tests/test_workers.py,sha256=MInwdkFY5LdmFB3o1odIaSD7AQZb3263hNafO1De5PE,2793
 tools/create_and_stake_service.py,sha256=1xwy_bJQI1j9yIQ968Oc9Db_F6mk1659LuuZntTASDE,3742
 tools/verify_drain.py,sha256=PkMjblyOOAuQge88FwfEzRtCYeEtJxXhPBmtQYCoQ-8,6743
-iwa-0.0.21.dist-info/METADATA,sha256=G_17iq72W9SNwyz3rr7rrvVgRA_iKLlVgxUnbrXdLNk,7295
-iwa-0.0.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iwa-0.0.21.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.0.21.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.0.21.dist-info/RECORD,,
+iwa-0.0.24.dist-info/METADATA,sha256=N-qgeL8ZAmzJTvBthIa65x8zoZpsmqVuFG4YZ_K7-kA,7295
+iwa-0.0.24.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+iwa-0.0.24.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.0.24.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.0.24.dist-info/RECORD,,

{iwa-0.0.21.dist-info → iwa-0.0.24.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any