iwa 0.0.26__py3-none-any.whl → 0.0.28__py3-none-any.whl

iwa/core/cli.py

@@ -7,6 +7,7 @@ from web3 import Web3
 
 from iwa.core.chain import ChainInterfaces
 from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.contracts.decoder import ErrorDecoder
 from iwa.core.keys import KeyStorage
 from iwa.core.services import PluginService
 from iwa.core.tables import list_accounts
@@ -206,6 +207,23 @@ def web_server(
     run_server(host=host, port=server_port)
 
 
+@iwa_cli.command("decode")
+def decode_hex(
+    hex_data: str = typer.Argument(..., help="The hex-encoded error data (e.g., 0xa43d6ada...)"),
+):
+    """Decode a hex error identifier into a human-readable message."""
+    decoder = ErrorDecoder()
+    results = decoder.decode(hex_data)
+
+    if not results:
+        typer.echo(f"Could not decode error data: {hex_data}")
+        return
+
+    typer.echo(f"\nDecoding results for {hex_data[:10]}:")
+    for _name, msg, source in results:
+        typer.echo(f"  [{source}] {msg}")
+
+
 @wallet_cli.command("drain")
 def drain_wallet(
     from_address_or_tag: str = typer.Option(..., "--from", "-f", help="From address or tag"),

iwa/core/contracts/contract.py

@@ -11,6 +11,7 @@ from web3.contract import Contract
 from web3.exceptions import ContractCustomError
 
 from iwa.core.chain import ChainInterfaces
+from iwa.core.contracts.decoder import ErrorDecoder
 from iwa.core.rpc_monitor import RPCMonitor
 from iwa.core.utils import configure_logger
 
@@ -111,7 +112,7 @@ class ContractInstance:
                 )
         return selectors
 
-    def decode_error(self, error_data: str) -> Optional[Tuple[str, str]]:
+    def decode_error(self, error_data: str) -> Optional[Tuple[str, str]]:  # noqa: C901
         """Decode error data from a failed transaction or call.
 
         Handles:
@@ -172,6 +173,16 @@ class ContractInstance:
                 logger.debug(f"Failed to decode Panic(uint256): {e}")
                 return ("Panic", "Failed to decode panic code")
 
+        # 4. Global Fallback Decoder
+        try:
+            global_results = ErrorDecoder().decode(error_data)
+            if global_results:
+                # Use the first match
+                error_name, error_msg, _ = global_results[0]
+                return (error_name, error_msg)
+        except Exception as e:
+            logger.debug(f"Global decoder failed: {e}")
+
         return None
 
     def _extract_error_data(self, exception: Exception) -> Optional[str]:

iwa/core/contracts/decoder.py

@@ -0,0 +1,154 @@
+"""Global error decoder for Ethereum contracts."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from eth_abi import decode
+from loguru import logger
+from web3 import Web3
+
+# Standard error selectors (copied from contract.py for consistency)
+ERROR_SELECTOR = "0x08c379a0"  # Error(string)
+PANIC_SELECTOR = "0x4e487b71"  # Panic(uint256)
+
+PANIC_CODES = {
+    0x00: "Generic compiler inserted panic",
+    0x01: "Assert failed",
+    0x11: "Arithmetic overflow/underflow",
+    0x12: "Division by zero",
+    0x21: "Invalid enum value",
+    0x22: "Storage byte array incorrectly encoded",
+    0x31: "Pop on empty array",
+    0x32: "Array index out of bounds",
+    0x41: "Too much memory allocated",
+    0x51: "Invalid internal function call",
+}
+
+
+class ErrorDecoder:
+    """Global registry of error selectors from all project ABIs."""
+
+    _instance = None
+    _selectors: Dict[str, List[Dict[str, Any]]] = {}  # selector -> list of possible decodings
+    _initialized = False
+
+    def __new__(cls):
+        """Singleton pattern."""
+        if cls._instance is None:
+            cls._instance = super(ErrorDecoder, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """Initialize and load all ABIs once."""
+        if self._initialized:
+            return
+        self.load_all_abis()
+        self._initialized = True
+
+    def load_all_abis(self):
+        """Find and load all ABI files in the project."""
+        # Find the root of the source tree
+        # Assuming we are in src/iwa/core/contracts/decoder.py
+        current_file = Path(__file__).resolve()
+        src_root = current_file.parents[3]  # Go up to 'src'
+
+        abi_files = list(src_root.glob("**/contracts/abis/*.json"))
+
+        # Also check core ABIs if they are in a different place
+        core_abi_path = src_root / "iwa" / "core" / "contracts" / "abis"
+        if core_abi_path.exists() and core_abi_path not in [f.parent for f in abi_files]:
+             abi_files.extend(list(core_abi_path.glob("*.json")))
+
+        logger.debug(f"Found {len(abi_files)} ABI files for error decoding.")
+
+        for abi_path in abi_files:
+            try:
+                with open(abi_path, "r", encoding="utf-8") as f:
+                    content = json.load(f)
+                    abi = content.get("abi") if isinstance(content, dict) and "abi" in content else content
+                    if isinstance(abi, list):
+                        self._process_abi(abi, abi_path.name)
+            except Exception as e:
+                logger.warning(f"Failed to load ABI {abi_path}: {e}")
+
+    def _process_abi(self, abi: List[Dict], source_name: str):
+        """Extract error selectors from an ABI."""
+        for entry in abi:
+            if entry.get("type") == "error":
+                name = entry["name"]
+                inputs = entry.get("inputs", [])
+                types = [i["type"] for i in inputs]
+                names = [i["name"] for i in inputs]
+
+                # Signature: Name(type1,type2,...)
+                types_str = ",".join(types)
+                signature = f"{name}({types_str})"
+                selector = "0x" + Web3.keccak(text=signature)[:4].hex()
+
+                decoding = {
+                    "name": name,
+                    "types": types,
+                    "arg_names": names,
+                    "source": source_name,
+                    "signature": signature
+                }
+
+                if selector not in self._selectors:
+                    self._selectors[selector] = []
+
+                # Avoid duplicates
+                if decoding not in self._selectors[selector]:
+                    self._selectors[selector].append(decoding)
+
+    def decode(self, error_data: str) -> List[Tuple[str, str, str]]:  # noqa: C901
+        """Decode hex error data.
+
+        Returns:
+            List of (error_name, formatted_message, source_abi)
+
+        """
+        if not error_data:
+            return []
+
+        if not error_data.startswith("0x"):
+            error_data = "0x" + error_data
+
+        if len(error_data) < 10:
+            return []
+
+        selector = error_data[:10].lower()
+        encoded_args = error_data[10:]
+
+        results = []
+
+        # 1. Check Standard Error(string)
+        if selector == ERROR_SELECTOR:
+            try:
+                decoded = decode(["string"], bytes.fromhex(encoded_args))
+                results.append(("Error", f"Error: {decoded[0]}", "Built-in"))
+            except Exception:
+                pass
+
+        # 2. Check Panic(uint256)
+        if selector == PANIC_SELECTOR:
+            try:
+                decoded = decode(["uint256"], bytes.fromhex(encoded_args))
+                code = decoded[0]
+                msg = PANIC_CODES.get(code, f"Unknown panic code {code}")
+                results.append(("Panic", f"Panic: {msg}", "Built-in"))
+            except Exception:
+                pass
+
+        # 3. Check Custom Errors
+        if selector in self._selectors:
+            for d in self._selectors[selector]:
+                try:
+                    decoded = decode(d["types"], bytes.fromhex(encoded_args))
+                    args_str = ", ".join(f"{n}={v}" for n, v in zip(d["arg_names"], decoded, strict=False))
+                    results.append((d["name"], f"{d['name']}({args_str})", d["source"]))
+                except Exception:
+                    # Try next possible decoding for this selector
+                    continue
+
+        return results

iwa/core/services/transaction.py

@@ -9,11 +9,14 @@ from web3 import exceptions as web3_exceptions
 from iwa.core.chain import ChainInterfaces
 from iwa.core.db import log_transaction
 from iwa.core.keys import KeyStorage
+from iwa.core.models import StoredSafeAccount
 from iwa.core.services.account import AccountService
 
 if TYPE_CHECKING:
     from iwa.core.chain import ChainInterface
 
+    # Circular import during type checking
+
 # ERC20 Transfer event signature: Transfer(address indexed from, address indexed to, uint256 value)
 TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
 
@@ -205,12 +208,13 @@ class TransferLogger:
 class TransactionService:
     """Manages transaction lifecycle: signing, sending, retrying."""
 
-    def __init__(self, key_storage: KeyStorage, account_service: AccountService):
+    def __init__(self, key_storage: KeyStorage, account_service: AccountService, safe_service=None):
         """Initialize TransactionService."""
         self.key_storage = key_storage
         self.account_service = account_service
+        self.safe_service = safe_service
 
-    def sign_and_send(
+    def sign_and_send(  # noqa: C901
         self,
         transaction: dict,
         signer_address_or_tag: str,
@@ -228,6 +232,14 @@ class TransactionService:
         if not self._prepare_transaction(tx, signer_address_or_tag, chain_interface):
             return False, {}
 
+        # CHECK FOR SAFE TRANSACTION
+        signer_account = self.account_service.resolve_account(signer_address_or_tag)
+        if isinstance(signer_account, StoredSafeAccount):
+            if not self.safe_service:
+                logger.error("Attempted Safe transaction but SafeService is not initialized.")
+                return False, {}
+            return self._execute_via_safe(tx, signer_account, chain_interface, chain_name, tags)
+
         # Mutable state for retry attempts
         state = {"gas_retries": 0, "max_gas_retries": 5}
 
@@ -367,6 +379,55 @@ class TransactionService:
 
         return list(set(final_tags))
 
+    def _execute_via_safe(
+        self,
+        tx: dict,
+        signer_account: StoredSafeAccount,
+        chain_interface,
+        chain_name: str,
+        tags: List[str] = None
+    ) -> Tuple[bool, Dict]:
+        """Execute transaction via SafeService."""
+        logger.info(f"Routing transaction via Safe {signer_account.address}...")
+
+        try:
+            # Extract basic params
+            to_addr = tx.get("to")
+            value = tx.get("value", 0)
+            data = tx.get("data", "")
+            if isinstance(data, bytes):
+                data = "0x" + data.hex()
+
+            # Execute
+            tx_hash = self.safe_service.execute_safe_transaction(
+                safe_address_or_tag=signer_account.address,
+                to=to_addr,
+                value=value,
+                chain_name=chain_name,
+                data=data
+            )
+
+            # Wait for receipt
+            receipt = chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
+
+            status = getattr(receipt, "status", None)
+            if status is None and isinstance(receipt, dict):
+                status = receipt.get("status")
+
+            if receipt and status == 1:
+                logger.info(f"Safe transaction executed successfully. Tx Hash: {tx_hash}")
+                self._log_successful_transaction(
+                    receipt, tx, signer_account, chain_name, bytes.fromhex(tx_hash.replace("0x", "")), tags, chain_interface
+                )
+                return True, receipt
+            else:
+                logger.error("Safe transaction failed (status 0).")
+                return False, {}
+
+        except Exception as e:
+            logger.exception(f"Safe transaction failed: {e}")
+            return False, {}
+
     def _is_gas_too_low_error(self, err_text: str) -> bool:
         """Check if error is due to low gas."""
         low_gas_signals = [

iwa/core/wallet.py

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

iwa/plugins/olas/importer.py

@@ -82,7 +82,13 @@ class DiscoveredService:
     service_name: Optional[str] = None
     # New fields for full service import
     staking_contract_address: Optional[str] = None
-    service_owner_address: Optional[str] = None
+    service_owner_eoa_address: Optional[str] = None
+    service_owner_multisig_address: Optional[str] = None
+
+    @property
+    def service_owner_address(self) -> Optional[str]:
+        """Backward compatibility: effective owner address."""
+        return self.service_owner_multisig_address or self.service_owner_eoa_address
 
     @property
     def agent_key(self) -> Optional[DiscoveredKey]:
@@ -517,7 +523,12 @@ class OlasServiceImporter:
         return keys
 
     def _extract_owner_address(self, service: DiscoveredService, operate_folder: Path) -> None:
-        """Extract owner address from wallets/ethereum.json."""
+        """Extract owner address from wallets/ethereum.json.
+
+        Handles two cases:
+        1. EOA is the owner (legacy).
+        2. Safe is the owner, and EOA is a signer (new staking programs).
+        """
         wallets_folder = operate_folder / "wallets"
         if not wallets_folder.exists():
             return
@@ -526,9 +537,35 @@ class OlasServiceImporter:
         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}")
+
+                # Check for "safes" entry which indicates the owner is a Safe
+                # Structure: "safes": { "gnosis": "0x..." }
+                if "safes" in data and FLAGS_OWNER_SAFE in data["safes"]: # Need to detect chain dynamically or iterate
+                     pass
+
+                # Logic update:
+                # 1. Capture EOA address always (it's the signer)
+                eoa_address = data.get("address")
+
+                # 2. Check for Safe Owner for the current service chain
+                safe_owner_address = None
+                if "safes" in data and isinstance(data["safes"], dict):
+                    # We try to match with service.chain_name if available, usually "gnosis"
+                    chain = service.chain_name or "gnosis"
+                    safe_owner_address = data["safes"].get(chain)
+
+                if safe_owner_address:
+                    # CASE: Owner is Safe
+                    service.service_owner_multisig_address = safe_owner_address
+                    service.service_owner_eoa_address = eoa_address # The EOA is the signer/controller
+
+                    logger.debug(f"Extracted Safe owner address: {safe_owner_address} (Signer: {eoa_address})")
+                elif eoa_address:
+                    # CASE: Owner is EOA
+                    service.service_owner_eoa_address = eoa_address
+                    service.service_owner_multisig_address = None
+                    logger.debug(f"Extracted EOA owner address: {eoa_address}")
+
             except (json.JSONDecodeError, IOError) as e:
                 logger.warning(f"Failed to parse {eth_json}: {e}")
 
@@ -541,14 +578,14 @@ class OlasServiceImporter:
                 existing_addrs.add(key.address.lower())
 
     def _infer_owner_address(self, service: DiscoveredService) -> None:
-        """Infer service_owner_address from keys with role='owner' if not already set."""
-        if service.service_owner_address:
+        """Infer service_owner_eoa_address from keys with role='owner' if not already set."""
+        if service.service_owner_eoa_address:
             return  # Already set
 
         for key in service.keys:
             if key.role == "owner" and key.address:
-                service.service_owner_address = key.address
-                logger.debug(f"Inferred owner address from key: {key.address}")
+                service.service_owner_eoa_address = key.address
+                logger.debug(f"Inferred owner EOA address from key: {key.address}")
                 return
 
     def _parse_keystore_file(
@@ -725,8 +762,14 @@ class OlasServiceImporter:
 
     def _import_discovered_safes(self, service: DiscoveredService, result: ImportResult) -> None:
         """Import Safe from the service if present."""
+        # 1. Import Agent Multisig (the one the agent controls)
         if service.safe_address:
-            safe_result = self._import_safe(service)
+            safe_result = self._import_safe(
+                address=service.safe_address,
+                signers=self._get_agent_signers(service),
+                tag_suffix="safe", # e.g. trader_zeta_safe
+                service_name=service.service_name
+            )
             if safe_result[0]:
                 result.imported_safes.append(service.safe_address)
             elif safe_result[1] == "duplicate":
@@ -734,6 +777,38 @@ class OlasServiceImporter:
             else:
                 result.errors.append(f"Safe {service.safe_address}: {safe_result[1]}")
 
+        # 2. Import Owner Safe (if it exists and is different)
+        if service.service_owner_multisig_address and service.service_owner_multisig_address != service.safe_address:
+             # Signer for Owner Safe is the EOA owner key
+            owner_signers = self._get_owner_signers(service)
+
+            safe_result = self._import_safe(
+                address=service.service_owner_multisig_address,
+                signers=owner_signers,
+                tag_suffix="owner_safe", # e.g. trader_zeta_owner_safe
+                service_name=service.service_name
+            )
+            if safe_result[0]:
+                 result.imported_safes.append(service.service_owner_multisig_address)
+                 logger.info(f"Imported Owner Safe {service.service_owner_multisig_address}")
+
+    def _get_agent_signers(self, service: DiscoveredService) -> List[str]:
+        """Get list of signers for the agent safe."""
+        signers = []
+        for key in service.keys:
+            if key.role == "agent":
+                signers.append(key.address)
+        return signers
+
+    def _get_owner_signers(self, service: DiscoveredService) -> List[str]:
+        """Get list of signers for the owner safe."""
+        signers = []
+        for key in service.keys:
+            # We look for keys marked as owner/operator
+            if key.role in ["owner", "operator"]:
+                signers.append(key.address)
+        return signers
+
     def _import_discovered_service_config(
         self, service: DiscoveredService, result: ImportResult
     ) -> None:
@@ -833,27 +908,26 @@ class OlasServiceImporter:
             i += 1
         return f"{base_tag}_{i}"
 
-    def _import_safe(self, service: DiscoveredService) -> Tuple[bool, str]:
-        """Import a Safe from a discovered service."""
-        if not service.safe_address:
+    def _import_safe(
+        self,
+        address: str,
+        signers: List[str] = None,
+        tag_suffix: str = "safe",
+        service_name: Optional[str] = None
+    ) -> Tuple[bool, str]:
+        """Import a generic Safe."""
+        if not address:
             return False, "no safe address"
 
         # Check for duplicate
-        existing = self.key_storage.find_stored_account(service.safe_address)
+        existing = self.key_storage.find_stored_account(address)
         if existing:
             return False, "duplicate"
 
-        # Get signers from agent keys
-        signers = []
-        for key in service.keys:
-            if key.role == "agent":
-                signers.append(key.address)
-
         # Generate tag
-
-        prefix = service.service_name or "imported"
+        prefix = service_name or "imported"
         prefix = re.sub(r"[^a-z0-9]+", "_", prefix.lower()).strip("_")
-        base_tag = f"{prefix}_safe"
+        base_tag = f"{prefix}_{tag_suffix}"
 
         existing_tags = {
             acc.tag for acc in self.key_storage.accounts.values() if hasattr(acc, "tag")
@@ -866,15 +940,15 @@ class OlasServiceImporter:
 
         safe_account = StoredSafeAccount(
             tag=tag,
-            address=service.safe_address,
-            chains=[service.chain_name],
+            address=address,
+            chains=["gnosis"],  # TODO: detecting chain dynamically would be better
             threshold=1,  # Default, accurate value requires on-chain query
-            signers=signers,
+            signers=signers or [],
         )
 
-        self.key_storage.accounts[service.safe_address] = safe_account
+        self.key_storage.accounts[address] = safe_account
         self.key_storage.save()
-        logger.info(f"Imported Safe {service.safe_address} as '{tag}'")
+        logger.info(f"Imported Safe {address} as '{tag}'")
         return True, "ok"
 
     def _import_service_config(self, service: DiscoveredService) -> Tuple[bool, str]:
@@ -901,7 +975,8 @@ class OlasServiceImporter:
                 service_id=service.service_id,
                 agent_ids=[25],  # Trader agents always use agent ID 25
                 multisig_address=service.safe_address,
-                service_owner_address=service.service_owner_address,
+                service_owner_eoa_address=service.service_owner_eoa_address,
+                service_owner_multisig_address=service.service_owner_multisig_address,
                 staking_contract_address=service.staking_contract_address,
                 token_address=str(OLAS_TOKEN_ADDRESS_GNOSIS),
             )
@@ -975,3 +1050,4 @@ class OlasServiceImporter:
             key.signature_failed = True
             logger.warning(f"Error verifying signature for key {key.address}: {e}")
 
+FLAGS_OWNER_SAFE="deprecated"

iwa/plugins/olas/models.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, root_validator
 
 from iwa.core.models import EthereumAddress
 
@@ -14,12 +14,40 @@ class Service(BaseModel):
     chain_name: str
     service_id: int  # Unique per chain
     agent_ids: List[int] = Field(default_factory=list)  # List of agent type IDs
-    service_owner_address: Optional[EthereumAddress] = None
+
+    # New explicit owner fields
+    service_owner_eoa_address: Optional[EthereumAddress] = None
+    service_owner_multisig_address: Optional[EthereumAddress] = None
+
+    # Deprecated fields (kept for migration, removed from physical model via aliasing/validation)
+    # Actually, we keep it optional but not used, or use migration logic.
+    # Let's remove it from fields and rely on before validator to map it to eoa.
+
     agent_address: Optional[EthereumAddress] = None
     multisig_address: Optional[EthereumAddress] = None
     staking_contract_address: Optional[EthereumAddress] = None
     token_address: Optional[EthereumAddress] = None
 
+    @root_validator(pre=True)
+    def migrate_owner_fields(cls, values):  # noqa: N805
+        """Migrate legacy service_owner_address to service_owner_eoa_address."""
+        # Check for legacy 'service_owner_address'
+        if "service_owner_address" in values and values["service_owner_address"]:
+            legacy_addr = values["service_owner_address"]
+
+            # If service_owner_eoa_address is missing, use legacy
+            if "service_owner_eoa_address" not in values or not values["service_owner_eoa_address"]:
+                values["service_owner_eoa_address"] = legacy_addr
+
+            # Remove legacy field from values so it doesn't cause extra field errors if we removed it from model
+            # Or if strict.
+        return values
+
+    @property
+    def service_owner_address(self) -> Optional[EthereumAddress]:
+        """Backward compatibility property: Returns effective owner (Safe if present, else EOA)."""
+        return self.service_owner_multisig_address or self.service_owner_eoa_address
+
     @property
     def key(self) -> str:
         """Unique key for this service (chain_name:service_id)."""
@@ -106,5 +134,8 @@ class OlasConfig(BaseModel):
         target = multisig_address.lower()
         for service in self.services.values():
             if service.multisig_address and str(service.multisig_address).lower() == target:
+                # The following line is from the Code Edit, but it does not fit syntactically here.
+                # It appears to be from a different file (decoder.py) as indicated by the instruction.
+                # args_str = ", ".join(f"{n}={v}" for n, v in zip(d["arg_names"], decoded, strict=False))
                 return service
         return None

iwa/plugins/olas/plugin.py

@@ -141,6 +141,20 @@ class OlasPlugin(Plugin):
             safe_text = service.safe_address
             if safe_exists:
                 safe_text += " [green]✓[/green]"
+
+                # Check if Agent is a signer
+                agent_key = next((k for k in service.keys if k.role == "agent"), None)
+                if agent_key and on_chain_signers:
+                    key_addr = agent_key.address.lower()
+                    if not key_addr.startswith("0x"):
+                        key_addr = "0x" + key_addr
+
+                    is_signer = key_addr in [s.lower() for s in on_chain_signers]
+                    if not is_signer:
+                        safe_text += f"\n[bold red]⚠ Agent {agent_key.address} - NOT A SIGNER![/bold red]"
+                    else:
+                        safe_text += f" (Signer: {agent_key.address[:6]}...)"
+
             elif safe_exists is False:
                 safe_text = (
                     f"[bold red]⚠ {service.safe_address} - DOES NOT EXIST ON-CHAIN![/bold red]"
@@ -163,26 +177,63 @@ class OlasPlugin(Plugin):
             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:
+    def _add_owner_info(self, table, service) -> None:  # noqa: C901
         """Add owner information to the display table."""
+        # 1. Display Signer/EOA Owner
         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)
+        if owner_key:
+             val = owner_key.address
+             if not val.startswith("0x"):
+                 val = "0x" + val
+
+             if owner_key.signature_verified:
+                 val = f"[green]{val}[/green]"
+             elif not owner_key.is_encrypted:
+                 val = f"[red]{val}[/red]"
+             status = "🔒 encrypted" if owner_key.is_encrypted else "🔓 plaintext"
+             table.add_row("Owner (EOA)", f"{val} {status}")
+        elif service.service_owner_eoa_address:
+             # Fallback if we have an address but no key object
+             table.add_row("Owner (EOA)", service.service_owner_eoa_address)
+        else:
+             table.add_row("Owner (EOA)", "[yellow]N/A[/yellow]")
+
+        # 2. Display Safe Owner
+        if service.service_owner_multisig_address:
+            # Check on-chain existence if possible (using same helper as agent safe)
+            on_chain_signers, safe_exists = self._get_safe_signers(
+                service.service_owner_multisig_address, service.chain_name
+            )
+            val = service.service_owner_multisig_address
+            if safe_exists:
+                val += " [green]✓[/green]"
+
+                # Check if EOA owner is a signer
+                if owner_key and on_chain_signers:
+                    key_addr = owner_key.address.lower()
+                    if not key_addr.startswith("0x"):
+                        key_addr = "0x" + key_addr
+
+                    is_signer = key_addr in [s.lower() for s in on_chain_signers]
+                    if not is_signer:
+                        # Ensure display has 0x
+                        disp_addr = owner_key.address
+                        if not disp_addr.startswith("0x"):
+                            disp_addr = "0x" + disp_addr
+                        val += f"\n[bold red]⚠ {disp_addr} - NOT A SIGNER![/bold red]"
+                    else:
+                        # Ensure display has 0x
+                        disp_addr = owner_key.address
+                        if not disp_addr.startswith("0x"):
+                            disp_addr = "0x" + disp_addr
+                        val += f" (Signer: {disp_addr[:6]}...)"
+
+            elif safe_exists is False:
+                val += " [bold red]⚠ DOES NOT EXIST![/bold red]"
+
+            table.add_row("Owner (Safe)", val)
         else:
-            table.add_row("Owner", "[red]Not detected[/red]")
+            table.add_row("Owner (Safe)", "[yellow]N/A[/yellow]")
 
     def _add_agent_info(self, table, service, on_chain_signers, safe_exists) -> None:
         """Add agent information to the display table."""

iwa/plugins/olas/service_manager/drain.py

@@ -59,9 +59,12 @@ class DrainManagerMixin:
 
         logger.info(f"Claiming {accrued_rewards / 1e18:.4f} OLAS rewards for service {service_id}")
 
+        # Use service owner which holds the reward rights (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
         # Prepare and send claim transaction
         claim_tx = staking_contract.prepare_claim_tx(
-            from_address=self.wallet.master_account.address,
+            from_address=owner_address,
             service_id=service_id,
         )
 
@@ -71,7 +74,7 @@ class DrainManagerMixin:
 
         success, receipt = self.wallet.sign_and_send_transaction(
             claim_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
             tags=["olas_claim_rewards"],
         )

iwa/plugins/olas/service_manager/lifecycle.py

@@ -522,9 +522,14 @@ class LifecycleManagerMixin:
             f"activation_value={activation_value} wei"
         )
 
-        logger.debug(f"[ACTIVATE] Preparing tx: service_id={service_id}, value={activation_value}")
+        # Use service owner which holds the NFT (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
+        logger.debug(
+            f"[ACTIVATE] Preparing tx from {owner_address}: service_id={service_id}, value={activation_value}"
+        )
         activate_tx = self.manager.prepare_activate_registration_tx(
-            from_address=self.wallet.master_account.address,
+            from_address=owner_address,
             service_id=service_id,
             value=activation_value,
         )
@@ -532,7 +537,7 @@ class LifecycleManagerMixin:
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=activate_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
         )
 
@@ -720,13 +725,16 @@ class LifecycleManagerMixin:
             f"total_value={total_value} wei"
         )
 
+        # Use service owner which holds the NFT (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
         logger.debug(
-            f"[REGISTER] Preparing tx: agent={agent_account_address}, "
+            f"[REGISTER] Preparing tx from {owner_address}: agent={agent_account_address}, "
             f"agent_ids={self.service.agent_ids}, value={total_value}"
         )
 
         register_tx = self.manager.prepare_register_agents_tx(
-            from_address=self.wallet.master_account.address,
+            from_address=owner_address,
             service_id=service_id,
             agent_instances=[agent_account_address],
             agent_ids=self.service.agent_ids,
@@ -736,7 +744,7 @@ class LifecycleManagerMixin:
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=register_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
             tags=["olas_register_agent"],
         )

iwa/plugins/olas/service_manager/staking.py

@@ -408,17 +408,20 @@ class StakingManagerMixin:
             True if approval succeeded, False otherwise.
 
         """
+        # Use service owner which holds the NFT (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
         # Approve service NFT - this is an ERC-721 approval, not ERC-20
-        logger.debug("[STAKE] Approving service NFT for staking contract...")
+        logger.debug(f"[STAKE] Approving service NFT for staking contract from {owner_address}...")
         approve_tx = self.registry.prepare_approve_tx(
-            from_address=self.wallet.master_account.address,
+            from_address=owner_address,
             spender=staking_contract.address,
             id_=self.service.service_id,
         )
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=approve_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
             tags=["olas_approve_service_nft"],
         )
@@ -452,16 +455,19 @@ class StakingManagerMixin:
             True if stake succeeded and ServiceStaked event was found.
 
         """
-        logger.debug("[STAKE] Preparing stake transaction...")
+        # Use service owner which holds the NFT (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
+        logger.debug(f"[STAKE] Preparing stake transaction from {owner_address}...")
         stake_tx = staking_contract.prepare_stake_tx(
-            from_address=self.wallet.master_account.address,
+            from_address=owner_address,
             service_id=self.service.service_id,
         )
         logger.debug(f"[STAKE] TX prepared: to={stake_tx.get('to')}")
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=stake_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
             tags=["olas_stake_service"],
         )
@@ -541,11 +547,16 @@ class StakingManagerMixin:
         except Exception as e:
             logger.warning(f"Could not verify staking duration: {e}. Proceeding with caution.")
 
+        # Use service owner which holds the NFT (not necessarily master)
+        owner_address = self.service.service_owner_address or self.wallet.master_account.address
+
         # Unstake the service
         try:
-            logger.info(f"Preparing unstake transaction for service {self.service.service_id}")
+            logger.info(
+                f"Preparing unstake transaction for service {self.service.service_id} from {owner_address}"
+            )
             unstake_tx = staking_contract.prepare_unstake_tx(
-                from_address=self.wallet.master_account.address,
+                from_address=owner_address,
                 service_id=self.service.service_id,
             )
             logger.info("Unstake transaction prepared successfully")
@@ -556,7 +567,7 @@ class StakingManagerMixin:
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=unstake_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
+            signer_address_or_tag=owner_address,
             chain_name=self.chain_name,
             tags=["olas_unstake_service"],
         )

iwa/plugins/olas/tests/test_importer_error_handling.py

@@ -272,15 +272,11 @@ def test_generate_tag_collisions(importer):
 
 def test_import_safe_duplicate(importer):
     """Test importing a Safe that already exists."""
-    from iwa.plugins.olas.importer import DiscoveredService
-
-    service = DiscoveredService(
-        service_id=1, chain_name="gnosis", safe_address="0xSafe", source_folder=Path("/tmp")
-    )
+    safe_address = "0xSafe"
 
     importer.key_storage.find_stored_account.return_value = MagicMock()
 
-    success, msg = importer._import_safe(service)
+    success, msg = importer._import_safe(safe_address)
     assert success is False
     assert msg == "duplicate"
 
@@ -310,22 +306,14 @@ def test_import_key_success(importer):
 
 def test_import_safe_success(importer):
     """Test successful Safe import with tag generation."""
-    from iwa.plugins.olas.importer import DiscoveredService
-
-    service = DiscoveredService(
-        service_id=1,
-        chain_name="gnosis",
-        safe_address="0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB",
-        source_folder=Path("/tmp"),
-        service_name="my_service",
-    )
+    safe_address = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
     importer.key_storage.find_stored_account.return_value = None
     importer.key_storage.accounts = {}
 
-    success, msg = importer._import_safe(service)
+    success, msg = importer._import_safe(safe_address, service_name="my_service")
     assert success is True
     assert msg == "ok"
-    assert "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB" in importer.key_storage.accounts
+    assert safe_address in importer.key_storage.accounts
 
 
 def test_import_service_config_success(importer):

{iwa-0.0.26.dist-info → iwa-0.0.28.dist-info}/METADATA

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

@@ -2,7 +2,7 @@ iwa/__init__.py,sha256=vu12UytYNREtMRvIWp6AfV1GgUe53XWwCMhYyqKAPgo,19
 iwa/__main__.py,sha256=eJU5Uxeu9Y7shWg5dt5Mcq0pMC4wFVNWjeYGKSf4Apw,88
 iwa/core/__init__.py,sha256=GJv4LJOXeZ3hgGvbt5I6omkoFkP2A9qhHjpDlOep9ik,24
 iwa/core/chainlist.py,sha256=IOnlfRFaPlzdg91HbILynzvRfEJ9afikjFUS06K4rfU,4021
-iwa/core/cli.py,sha256=GCrHSUp5W1KdLHoWbk0aCLTphkKDLROoFh82uyUqdY8,7729
+iwa/core/cli.py,sha256=7zKhPq5Yeb8yq3J3JpSGX5uHPrL6xkm79r2715ltzwo,8306
 iwa/core/constants.py,sha256=_CYUVQpR--dRPuxotsmbzQE-22y61tlnjUD7IhlvVVA,997
 iwa/core/db.py,sha256=WI-mP0tQAmwFPeEi9w7RCa_Mcf_zBfd_7JcbHJwU1aU,10377
 iwa/core/ipfs.py,sha256=aHjq_pflgwDVHl8g5EMQv0q2RAmMs-a0pOTVsj_L5xE,4980
@@ -19,7 +19,7 @@ iwa/core/test.py,sha256=gey0dql5eajo1itOhgkSrgfyGWue2eSfpr0xzX3vc38,643
 iwa/core/types.py,sha256=EfDfIwLajTNK-BP9K17QLOIsGCs8legplKI_bUD_NjM,1992
 iwa/core/ui.py,sha256=DglmrI7XhUmOpLn9Nog9Cej4r-VT0JGFkuSNBx-XorQ,3131
 iwa/core/utils.py,sha256=shJuANkXSWVO3NF49syPA9hCG7H5AzaMJOG8V4fo6IM,4279
-iwa/core/wallet.py,sha256=sNFK-_0y-EgeLpNHt9o5tCqTM0oVqJra-eAWjR7AgyU,13038
+iwa/core/wallet.py,sha256=GI83BOFGTto6u8LPKepJDqWxxNsHqfNF-vCxy4pTk3U,13057
 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=04eGlhonHAvxFnqLoHRWUaQBzys6jW6BppUuNNjlnSk,18809
@@ -28,7 +28,8 @@ iwa/core/chain/models.py,sha256=0OgBo08FZEQisOdd00YUMXSAV7BC0CcWpqJ2y-gs0cI,4863
 iwa/core/chain/rate_limiter.py,sha256=gU7TmWdH9D_wbXKT1X7mIgoIUCWVuebgvRhxiyLGAmI,6613
 iwa/core/contracts/__init__.py,sha256=P5GFY_pnuI02teqVY2U0t98bn1_SSPAbcAzRMpCdTi4,34
 iwa/core/contracts/cache.py,sha256=7wGQgyXAmofvx-irbxSnGgIDzQik6Pcpm7up6wMQcoo,4454
-iwa/core/contracts/contract.py,sha256=DCSQmlOom_SkGXElcr1VQyAt2nt0GjkYhLpiQsWDJPY,12810
+iwa/core/contracts/contract.py,sha256=RJaKh05p1MdgsCd8v799LwW1apkDboRDCu8Kah02760,13254
+iwa/core/contracts/decoder.py,sha256=HaPw43ZAGswaiLPasMNU2rXKSvozb5t-O46VzJ-YH-U,5488
 iwa/core/contracts/erc20.py,sha256=VqriOdUXej0ilTgpukpm1FUF_9sSrVMAPuEpIvyZ2SQ,2646
 iwa/core/contracts/multisend.py,sha256=tSdBCWe7LSdBoKZ7z2QebmRFK4M2ln7H3kmJBeEb4Ho,2431
 iwa/core/contracts/abis/erc20.json,sha256=vrdExMWcIogg_nO59j1Pmipmpa2Ulj3oCCdcdrrFVCE,16995
@@ -39,7 +40,7 @@ iwa/core/services/account.py,sha256=01MoEvl6FJlMnMB4fGwsPtnGa4kgA-d5hJeKu_ACg7Y,
 iwa/core/services/balance.py,sha256=mPE12CuOFfCaJXaQXWOcQM1O03ZF3ghpy_-oOjNk_GE,4104
 iwa/core/services/plugin.py,sha256=GNNlbtELyHl7MNVChrypF76GYphxXduxDog4kx1MLi8,3277
 iwa/core/services/safe.py,sha256=ZmgVwbQhYlH5r3qhlY5uP8nCPtkkvV3sNnYG7_UCWUQ,14831
-iwa/core/services/transaction.py,sha256=DiEVwE1L_UpCyC5UmknaRwRYRxsDlAkwMQRN64NiwIQ,15162
+iwa/core/services/transaction.py,sha256=1O8FAmXZak2oVu15ooUQsc0ByIS2F-O0vWxcAV2ylqk,17525
 iwa/core/services/transfer/__init__.py,sha256=ZJfshFxJRsp8rkOqfVvd1cqEzIJ9tqBJh8pc0l90GLk,5576
 iwa/core/services/transfer/base.py,sha256=sohz-Ss2i-pGYGl4x9bD93cnYKcSvsXaXyvyRawvgQs,9043
 iwa/core/services/transfer/erc20.py,sha256=958ctXPWxq_KSQNoaG7RqWbC8SRb9NB3MzhtC2dp_NU,8960
@@ -61,10 +62,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=A7trGY8yz-uB0MNDcC7W3U_FR_wSECoFnMkzCVw3rlc,38059
+iwa/plugins/olas/importer.py,sha256=HvPHnY4pcHNm2Zr7ELYvFdzK-d52HM1Dm6PVvWhZSlQ,41570
 iwa/plugins/olas/mech_reference.py,sha256=CaSCpQnQL4F7wOG6Ox6Zdoy-uNEQ78YBwVLILQZKL8Q,5782
-iwa/plugins/olas/models.py,sha256=xC5hYakX53pBT6zZteM9cyiC7t6XRLLpobjQmDYueOo,3520
-iwa/plugins/olas/plugin.py,sha256=7vTnr7OUZhzXKxyQjjp5oiRkMsB5c-1arDW4YYoV9RM,13156
+iwa/plugins/olas/models.py,sha256=36N2Wuia7DVfpekJJ2pXPeS0lqhe5ED-Hjdox9YQG2c,5230
+iwa/plugins/olas/plugin.py,sha256=zOPWyoVkSVh6guJ3TZj5enJFuiIbP3fRM8FkziPB-c0,15606
 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
@@ -86,13 +87,13 @@ iwa/plugins/olas/scripts/test_full_mech_flow.py,sha256=Fqoq5bn7Z_3YyRrnuqNAZy9cw
 iwa/plugins/olas/scripts/test_simple_lifecycle.py,sha256=8T50tOZx3afeECSfCNAb0rAHNtYOsBaeXlMwKXElCk8,2099
 iwa/plugins/olas/service_manager/__init__.py,sha256=GXiThMEY3nPgHUl1i-DLrF4h96z9jPxxI8Jepo2E1PM,1926
 iwa/plugins/olas/service_manager/base.py,sha256=EBPg0ymqgtAb7ZvVSfTt31QYgv_6gp4UAc6je00NLAg,5009
-iwa/plugins/olas/service_manager/drain.py,sha256=IS7YYKuQdkULcNdxfHVzjcq95pXKdpajolzLL78u4jc,12430
-iwa/plugins/olas/service_manager/lifecycle.py,sha256=Lr2O3Vmv8dLlzwUVt_Ga8bFRQD3TbrM6LGs5kKeiAOE,48410
+iwa/plugins/olas/service_manager/drain.py,sha256=1Ku7axThwLtKxaNTkwhP4j1yjIXbFXAqNFDrCSmgfto,12569
+iwa/plugins/olas/service_manager/lifecycle.py,sha256=Aibd4D-R_UjFEqSTEsVaMFKbrtEOY8fo0Td0eFYjcDI,48732
 iwa/plugins/olas/service_manager/mech.py,sha256=NVzVbEmyOe3wK92VEzCCOSuy3HDkEP1MSoVt7Av8Psk,27949
-iwa/plugins/olas/service_manager/staking.py,sha256=7REp_HziKtqF9uSvbcq01C9XiaxgVT3gCimuLAAdNnM,28219
+iwa/plugins/olas/service_manager/staking.py,sha256=4WS1m1E1ddX5EbQuvNnNswZjT20nc7I9IKzjrBuUCFw,28701
 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=O5yd7w_eURtkJb8_IwAGkz8fyHLTzYfI5c2JxWl3oOo,12081
+iwa/plugins/olas/tests/test_importer_error_handling.py,sha256=yHpdxfN20gnZ1cHPJqk9xHC_26jyVN8kiziY-sl4FuA,11696
 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
@@ -157,7 +158,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.26.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.0.28.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 +211,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.26.dist-info/METADATA,sha256=Wqiy2X1x-bMEyAb6hYzuWfhXhSp65n4HnCD5lK4GO5c,7295
-iwa-0.0.26.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-iwa-0.0.26.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.0.26.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.0.26.dist-info/RECORD,,
+iwa-0.0.28.dist-info/METADATA,sha256=400-yQdPxQzEfg4h9h4C6UrD5gcjUYp0DhY4T965xnM,7295
+iwa-0.0.28.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+iwa-0.0.28.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.0.28.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.0.28.dist-info/RECORD,,