iwa 0.0.20__py3-none-any.whl → 0.0.23__py3-none-any.whl

iwa/core/chain/interface.py

@@ -48,10 +48,17 @@ class ChainInterface:
         self._rotation_lock = threading.Lock()
         self._init_web3()
 
+    @property
+    def current_rpc(self) -> str:
+        """Get the current active RPC URL."""
+        if not self.chain.rpcs:
+            return ""
+        return self.chain.rpcs[self._current_rpc_index]
+
     @property
     def is_tenderly(self) -> bool:
         """Check if connected to Tenderly vNet."""
-        rpc = self.chain.rpc or ""
+        rpc = self.current_rpc or ""
         return "tenderly" in rpc.lower() or "virtual" in rpc.lower()
 
     def init_block_tracking(self):

iwa/core/monitor.py

@@ -24,7 +24,7 @@ class EventMonitor:
         self.chain_interface = ChainInterfaces().get(chain_name)
         self.web3 = self.chain_interface.web3
         self.running = False
-        if self.chain_interface.chain.rpc:
+        if self.chain_interface.current_rpc:
             try:
                 self.last_checked_block = self.web3.eth.block_number
             except Exception:
@@ -39,7 +39,7 @@ class EventMonitor:
             f"Starting EventMonitor for {len(self.addresses)} addresses on {self.chain_interface.chain.name}"
         )
 
-        if not self.chain_interface.chain.rpc:
+        if not self.chain_interface.current_rpc:
             logger.error(
                 f"Cannot start EventMonitor: No RPC URL found for chain {self.chain_interface.chain.name}"
             )

iwa/core/services/safe.py

@@ -102,7 +102,7 @@ class SafeService:
 
         # Use ChainInterface which has proper RPC rotation and parsing
         chain_interface = ChainInterfaces().get(chain_name)
-        return EthereumClient(chain_interface.chain.rpc)
+        return EthereumClient(chain_interface.current_rpc)
 
     def _deploy_safe_contract(
         self,
@@ -254,7 +254,7 @@ class SafeService:
 
                 # Use ChainInterface which has proper RPC rotation and parsing
                 chain_interface = ChainInterfaces().get(chain)
-                ethereum_client = EthereumClient(chain_interface.chain.rpc)
+                ethereum_client = EthereumClient(chain_interface.current_rpc)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 

iwa/plugins/gnosis/safe.py

@@ -30,7 +30,7 @@ class SafeMultisig:
         from iwa.core.chain import ChainInterfaces
 
         chain_interface = ChainInterfaces().get(chain_name.lower())
-        ethereum_client = EthereumClient(chain_interface.chain.rpc)
+        ethereum_client = EthereumClient(chain_interface.current_rpc)
         self.multisig = Safe(safe_account.address, ethereum_client)
         self.ethereum_client = ethereum_client
 

iwa/plugins/gnosis/tests/test_safe.py

@@ -42,7 +42,7 @@ def test_init(safe_account, mock_settings, mock_safe_eth):
     """Test initialization."""
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         ms = SafeMultisig(safe_account, "gnosis")
         assert ms.multisig is not None
         mock_safe_eth[0].assert_called_with("http://rpc")  # EthereumClient init

iwa/plugins/olas/importer.py

@@ -17,6 +17,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 +48,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 +79,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 +93,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 +121,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 +140,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 +163,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 +230,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,12 +267,13 @@ 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)
+                self._verify_key_signature(key)
 
         # Also check keys.json (array of keystores)
         keys_file = folder / "keys.json"
@@ -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:
@@ -698,6 +866,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 +880,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
@@ -734,3 +906,59 @@ 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}")
+            pass
+        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
@@ -73,12 +74,12 @@ class OlasPlugin(Plugin):
 
             try:
                 chain_interface = ChainInterfaces().get(chain_name)
-                if not chain_interface.chain.rpcs:
+                if not chain_interface.current_rpc:
                     return None, None
             except ValueError:
                 return None, None  # Chain not supported/configured
 
-            ethereum_client = EthereumClient(chain_interface.chain.rpc)
+            ethereum_client = EthereumClient(chain_interface.current_rpc)
             safe = Safe(safe_address, ethereum_client)
             owners = safe.retrieve_owners()
             return owners, True
@@ -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
@@ -105,7 +105,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 1. No RPC configured
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = []
+        mock_ci.get.return_value.current_rpc = ""
         signers, exists = plugin._get_safe_signers("0x1", "gnosis")
         assert signers is None
         assert exists is None
@@ -113,8 +113,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 2. Safe doesn't exist (raises exception)
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.side_effect = Exception("Generic error")
@@ -126,8 +125,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 3. Success path
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.return_value = ["0xAgent"]
@@ -187,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/tui/rpc.py

@@ -38,7 +38,7 @@ class RPCView(Static):
                 results.append((chain_name, "N/A", "Not Configured", "-"))
                 continue
 
-            rpc_url = interface.chain.rpc
+            rpc_url = interface.current_rpc
             if not rpc_url:
                 results.append((chain_name, "None", "Missing URL", "-"))
                 continue

iwa/tui/screens/wallets.py

@@ -381,7 +381,7 @@ class WalletsScreen(VerticalScroll):
         self.stop_monitor()
         addresses = [acc.address for acc in self.wallet.key_storage.accounts.values()]
         for chain_name, interface in ChainInterfaces().items():
-            if interface.chain.rpc:
+            if interface.current_rpc:
                 monitor = EventMonitor(addresses, self.monitor_callback, chain_name)
 
                 # Worker wrapper
@@ -497,7 +497,7 @@ class WalletsScreen(VerticalScroll):
         """Handle blockchain selection changes."""
         if event.value and event.value != self.active_chain:
             interface = ChainInterfaces().get(event.value)
-            if not interface or not interface.chain.rpc:
+            if not interface or not interface.current_rpc:
                 self.notify(f"No RPC for {event.value}", severity="warning")
                 event.control.value = self.active_chain
                 return

iwa/tui/tests/test_rpc.py

@@ -71,7 +71,7 @@ def test_check_rpcs_success(rpc_view, mock_chain_interfaces):
     """Test check_rpcs with successful connections."""
     # Setup mock chain interfaces
     mock_gnosis = MagicMock()
-    mock_gnosis.chain.rpc = "http://gnosis"
+    mock_gnosis.current_rpc = "http://gnosis"
     mock_gnosis.web3.is_connected.return_value = True
 
     mock_chain_interfaces.get.side_effect = lambda name: mock_gnosis if name == "gnosis" else None
@@ -99,7 +99,7 @@ def test_check_rpcs_success(rpc_view, mock_chain_interfaces):
 def test_check_rpcs_error(rpc_view, mock_chain_interfaces):
     """Test check_rpcs with connection error."""
     mock_eth = MagicMock()
-    mock_eth.chain.rpc = "http://eth"
+    mock_eth.current_rpc = "http://eth"
     mock_eth.web3.is_connected.side_effect = Exception("Connection fail")
 
     mock_chain_interfaces.get.side_effect = lambda name: mock_eth if name == "ethereum" else None

iwa/tui/widgets/base.py

@@ -39,7 +39,7 @@ class ChainSelector(Horizontal):
 
         for name in chain_names:
             interface = ChainInterfaces().get(name)
-            if interface.chain.rpc:
+            if interface.current_rpc:
                 label = name.title()
                 chain_options.append((label, name))
             else:

{iwa-0.0.20.dist-info → iwa-0.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.20
+Version: 0.0.23
 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.20.dist-info → iwa-0.0.23.dist-info}/RECORD

@@ -9,7 +9,7 @@ iwa/core/ipfs.py,sha256=aHjq_pflgwDVHl8g5EMQv0q2RAmMs-a0pOTVsj_L5xE,4980
 iwa/core/keys.py,sha256=ckacVZxm_02V9hlmHIxz-CkxjXdGHqvGGAXfO6EeHCw,22365
 iwa/core/mnemonic.py,sha256=LiG1VmpydQoHQ0pHUJ1OIlrWJry47VSMnOqPM_Yk-O8,12930
 iwa/core/models.py,sha256=kBQ0cBe6uFmL2QfW7mjKiMFeZxhT-FRN-RyK3Ko0vE8,12849
-iwa/core/monitor.py,sha256=OmhKVMkfhvtxig3wDUL6iGwBIClTx0YUqMncCao4SqI,7953
+iwa/core/monitor.py,sha256=6hQHAdJIsyoOwnZ9KdYDk_k0mclgr94iFk8V6BtatFQ,7957
 iwa/core/plugins.py,sha256=FLvOG4S397fKi0aTH1fWBEtexn4yvGv_QzGWqFrhSKE,1102
 iwa/core/pricing.py,sha256=uENpqVMmuogZHctsLuEsU7WJ1cLSNAI-rZTtbpTDjeQ,4048
 iwa/core/rpc_monitor.py,sha256=-NHR1Mn2IJKJ9x975NGfsze_shI12yL0OyTPtmjUMKg,1661
@@ -22,7 +22,7 @@ iwa/core/utils.py,sha256=shJuANkXSWVO3NF49syPA9hCG7H5AzaMJOG8V4fo6IM,4279
 iwa/core/wallet.py,sha256=sNFK-_0y-EgeLpNHt9o5tCqTM0oVqJra-eAWjR7AgyU,13038
 iwa/core/chain/__init__.py,sha256=XJMmn0ed-_aVkY2iEMKpuTxPgIKBd41dexSVmEZTa-o,1604
 iwa/core/chain/errors.py,sha256=9SEbhxZ-qASPkzt-DoI51qq0GRJVqRgqgL720gO7a64,1275
-iwa/core/chain/interface.py,sha256=uUIUo9Q6Sr4h9AjqFe6WqQzdbMs9VkJcUj0mgd6lfx4,18602
+iwa/core/chain/interface.py,sha256=04eGlhonHAvxFnqLoHRWUaQBzys6jW6BppUuNNjlnSk,18809
 iwa/core/chain/manager.py,sha256=cFEzh6pK5OyVhjhpeMAqhc9RnRDQR1DjIGiGKp-FXBI,1159
 iwa/core/chain/models.py,sha256=0OgBo08FZEQisOdd00YUMXSAV7BC0CcWpqJ2y-gs0cI,4863
 iwa/core/chain/rate_limiter.py,sha256=gU7TmWdH9D_wbXKT1X7mIgoIUCWVuebgvRhxiyLGAmI,6613
@@ -38,7 +38,7 @@ iwa/core/services/__init__.py,sha256=ab5pYzmu3LrZLTO5N-plx6Rp4R0hBEnbbzsgz84zWGM
 iwa/core/services/account.py,sha256=01MoEvl6FJlMnMB4fGwsPtnGa4kgA-d5hJeKu_ACg7Y,1982
 iwa/core/services/balance.py,sha256=mPE12CuOFfCaJXaQXWOcQM1O03ZF3ghpy_-oOjNk_GE,4104
 iwa/core/services/plugin.py,sha256=GNNlbtELyHl7MNVChrypF76GYphxXduxDog4kx1MLi8,3277
-iwa/core/services/safe.py,sha256=ytNJMndXrzTMHwhDZKYLIh4Q0UTWDBgQgTpof-UqIkA,14827
+iwa/core/services/safe.py,sha256=ZmgVwbQhYlH5r3qhlY5uP8nCPtkkvV3sNnYG7_UCWUQ,14831
 iwa/core/services/transaction.py,sha256=DiEVwE1L_UpCyC5UmknaRwRYRxsDlAkwMQRN64NiwIQ,15162
 iwa/core/services/transfer/__init__.py,sha256=ZJfshFxJRsp8rkOqfVvd1cqEzIJ9tqBJh8pc0l90GLk,5576
 iwa/core/services/transfer/base.py,sha256=sohz-Ss2i-pGYGl4x9bD93cnYKcSvsXaXyvyRawvgQs,9043
@@ -51,20 +51,20 @@ iwa/plugins/__init__.py,sha256=zy-DjOZn8GSgIETN2X_GAb9O6yk71t6ZRzeUgoZ52KA,23
 iwa/plugins/gnosis/__init__.py,sha256=dpx0mE84eV-g5iZaH5nKivZJnoKWyRFX5rhdjowBwuU,114
 iwa/plugins/gnosis/cow_utils.py,sha256=iSvbfgTr2bCqRsUznKCWqmoTnyuX-WZX4oh0E-l3XBU,2263
 iwa/plugins/gnosis/plugin.py,sha256=AgkgOGYfnrcjWrPUiAvySMj6ITnss0SFXiEi6Z6fnMs,1885
-iwa/plugins/gnosis/safe.py,sha256=aDcBz50Bliur90sVqxgjGoQJyCqsfZlm0PDsmWIDBak,5517
+iwa/plugins/gnosis/safe.py,sha256=ye5GQhzKALPNiyJhr7lyrhDgdrDyIj_h3TN2QWI4Xds,5519
 iwa/plugins/gnosis/cow/__init__.py,sha256=lZN5QpIYWL67rE8r7z7zS9dlr8OqFrYeD9T4-RwUghU,224
 iwa/plugins/gnosis/cow/quotes.py,sha256=u2xFKgL7QTKqCkSPMv1RHaXvZ6WzID4haaZDMVS42Bs,5177
 iwa/plugins/gnosis/cow/swap.py,sha256=XZdvJbTbh54hxer7cKkum7lNQ-03gddMK95K3MenaFE,15209
 iwa/plugins/gnosis/cow/types.py,sha256=-9VRiFhAkmN1iIJ95Pg7zLFSeXtkkW00sl13usxi3o8,470
 iwa/plugins/gnosis/tests/test_cow.py,sha256=iVy5ockMIcPZWsX4WGXU91DhBsYEZ5NOxtFzAQ2sK3o,8440
-iwa/plugins/gnosis/tests/test_safe.py,sha256=pw1zrYvAiVtmPIU5k7BtOQpDNAQTSTrLIaeljCjSahc,3216
+iwa/plugins/gnosis/tests/test_safe.py,sha256=hQHVHBWQhGnuvzvx4U9fOWEwASJWwql42q6cfRcuAls,3218
 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=gf6BQKcaaPiFnjiBW3tv4ZVp2HoHw4xY1NS6r4Ip-8o,37447
 iwa/plugins/olas/mech_reference.py,sha256=CaSCpQnQL4F7wOG6Ox6Zdoy-uNEQ78YBwVLILQZKL8Q,5782
 iwa/plugins/olas/models.py,sha256=xC5hYakX53pBT6zZteM9cyiC7t6XRLLpobjQmDYueOo,3520
-iwa/plugins/olas/plugin.py,sha256=S_vnvZ02VdVWD7N5kp7u5JIRQ2JLtfwGDZ7OHkAN0M8,9390
+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=xevLYmdU4zd5FyEEEn9gvzGimPztmt6vymybeZHXnq8,8507
+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
@@ -125,18 +125,18 @@ iwa/tools/test_chainlist.py,sha256=9J06sTsKgnEcN7WSn-YgJkCHhfbGDdVS-KNMDBhYllA,1
 iwa/tools/wallet_check.py,sha256=IQLgb8oCt4oG6FMEAqzUxM57DLv_UE24dFUSVxtBo_Y,4774
 iwa/tui/__init__.py,sha256=XYIZNQNy-fZC1NHHM0sd9qUO0vE1slml-cm0CpQ4NLY,27
 iwa/tui/app.py,sha256=XDQ4nAPGBwhrEmdL_e3V8oYSOho8pY7jsd3C_wk92UU,4163
-iwa/tui/rpc.py,sha256=4q2zcBu7XXDU9c66UYtfbXiNdQyS_uLa9xOs3UmPOO0,2131
+iwa/tui/rpc.py,sha256=iEp7aQ2MZxeXWqvxYud_5Y5oX2NoweMd1DQQlGYBGv8,2133
 iwa/tui/workers.py,sha256=lvzbIS375_H1rj7-9d-w0PKnkDJ4lW_13aWzZRaX9fY,1192
 iwa/tui/modals/__init__.py,sha256=OyrjWjaPqQAllZcUJ-Ac_e1PtTouJy8m1eGo132p-EA,130
 iwa/tui/modals/base.py,sha256=q9dEV6We_SPxbMRh711amFDwAOBywD00Qg0jcqvh5LE,12060
 iwa/tui/screens/__init__.py,sha256=j0brLsuVd9M8hM5LHH05E7manY3ZVj24yf7nFyGryp4,31
-iwa/tui/screens/wallets.py,sha256=F_1feKuml3rUUHSfdT2XmgBIViGHNrdQeUcgpFUb0Ys,30821
+iwa/tui/screens/wallets.py,sha256=U6IUbV_7ByAyUi3aBVdFr3A1QlGzNORRE4uOHBQXQB0,30825
 iwa/tui/tests/test_app.py,sha256=F0tJthsyWzwNbHcGtiyDQtKDPn3m9N1qt2vMGiXrQTQ,3868
-iwa/tui/tests/test_rpc.py,sha256=chH9b6GunfymaYdqz3GVQ_LQui4zihyBkrCG6xOUY1Q,4326
+iwa/tui/tests/test_rpc.py,sha256=4m2HC-R5R9kO5pluo2G_CrTBQv63YYrdZNufTjtnGUk,4330
 iwa/tui/tests/test_wallets_refactor.py,sha256=71G3HLbhTtgDy3ffVbYv0MFYRgdYd-NWGBdvdzW4M9c,998
 iwa/tui/tests/test_widgets.py,sha256=C9UgIGeWRaQ459JygFEQx-7hOi9mWrSUDDIMZH1ge50,3994
 iwa/tui/widgets/__init__.py,sha256=UzD6nJbwv9hOtkWl9I7faXm1a-rcu4xFRxrf4KBwwY4,161
-iwa/tui/widgets/base.py,sha256=G844GU61qSS6AgY5NxmOVHTghbgHlyTfo8hhE2VUrqQ,3379
+iwa/tui/widgets/base.py,sha256=Z8FigMhsfD76PkFVERqMaotd-xwXfuFZm_8TmCMOsl4,3381
 iwa/web/dependencies.py,sha256=0_dAJlRh6gKrUDRPKUe92eshFsg572yx_H0lQgSqGDA,2103
 iwa/web/models.py,sha256=MSD9WPy_Nz_amWgoo2KSDTn4ZLv_AV0o0amuNtSf-68,3035
 iwa/web/server.py,sha256=4ZLVFEKoGs_NoCcXMeyYzDNdxUXazjwHQaX7CR1pwHE,5239
@@ -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.20.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.0.23.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
@@ -182,7 +182,7 @@ tests/test_migration.py,sha256=fYoxzI3KqGh0cPV0bFcbvGrAnKcNlvnwjggG_uD0QGo,1789
 tests/test_mnemonic.py,sha256=BFtXMMg17uHWh_H-ZwAOn0qzgbUCqL8BRLkgRjzfzxo,7379
 tests/test_modals.py,sha256=R_lXa7wnnGewAP5jJvVZDyQyY1FbE98IeO2B7y3x86c,2945
 tests/test_models.py,sha256=1bEfPiDVgEdtwFEzwecSPAHjCF8kjOPSMeQExJ7eCJ4,7107
-tests/test_monitor.py,sha256=P_hF61VMlCX2rh9yu_a6aKhlgXOAcCMGOZRntjcqrd0,7255
+tests/test_monitor.py,sha256=dRVS6EkTwfvGEOg7t0dVhs6M3oEZExBH7iBZe6hmk4M,7261
 tests/test_multisend.py,sha256=IvXpwnC5xSDRCyCDGcMdO3L-eQegvdjAzHZB0FoVFUI,2685
 tests/test_plugin_service.py,sha256=ZEe37kV_sv4Eb04032O1hZIoo9yf5gJo83ks7Grzrng,3767
 tests/test_pricing.py,sha256=ptu_2Csc6d64bIzMMw3TheJge2Kfn05Gs-twz_KmBzg,5276
@@ -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.20.dist-info/METADATA,sha256=_ERQ1f_nDtVFZClmaQ4vW6o6Yso2JjqumBbS56JJCCs,7295
-iwa-0.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iwa-0.0.20.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.0.20.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.0.20.dist-info/RECORD,,
+iwa-0.0.23.dist-info/METADATA,sha256=M0c-f0k7QPegtSsPkXm8gP8Ed12IS_8zEJZMNGMK3Ug,7295
+iwa-0.0.23.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+iwa-0.0.23.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.0.23.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.0.23.dist-info/RECORD,,

{iwa-0.0.20.dist-info → iwa-0.0.23.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
 

tests/test_monitor.py

@@ -12,7 +12,7 @@ def mock_chain_interfaces():
         instance = mock.return_value
         gnosis_interface = MagicMock()
         gnosis_interface.chain.name = "Gnosis"
-        gnosis_interface.chain.rpc = "https://rpc"
+        gnosis_interface.current_rpc = "https://rpc"
         gnosis_interface.web3 = MagicMock()
         instance.get.return_value = gnosis_interface
         yield instance
@@ -46,7 +46,7 @@ def test_monitor_init_rpc_fail(mock_chain_interfaces, mock_callback):
 
 def test_monitor_init_no_rpc(mock_chain_interfaces, mock_callback):
     chain_interface = mock_chain_interfaces.get.return_value
-    chain_interface.chain.rpc = ""
+    chain_interface.current_rpc = ""
 
     monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)
     assert monitor.last_checked_block == 0
@@ -54,7 +54,7 @@ def test_monitor_init_no_rpc(mock_chain_interfaces, mock_callback):
 
 def test_start_no_rpc(mock_chain_interfaces, mock_callback):
     chain_interface = mock_chain_interfaces.get.return_value
-    chain_interface.chain.rpc = ""
+    chain_interface.current_rpc = ""
 
     monitor = EventMonitor(["0x1234567890123456789012345678901234567890"], mock_callback)