refactor: explicit service owner eoa/multisig support

Author: dvilelaf

src/iwa/plugins/olas/importer.py

@@ -82,8 +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_safe: Optional[str] = None  # To store the Safe Owner address if it exists
+    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]:
@@ -551,14 +556,14 @@ def _extract_owner_address(self, service: DiscoveredService, operate_folder: Pat
 
                 if safe_owner_address:
                     # CASE: Owner is Safe
-                    service.service_owner_address = safe_owner_address # The Safe is the official owner
-                    service.service_owner_safe = safe_owner_address
-                    # We also need to ensure the EOA is imported. 'check_wallet' usually handles the EOA.
-                    # But we need to link them.
+                    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_address = eoa_address
+                    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:
@@ -573,14 +578,14 @@ def _merge_unique_keys(self, service: DiscoveredService, new_keys: List[Discover
                 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(
@@ -774,19 +779,19 @@ def _import_discovered_safes(self, service: DiscoveredService, result: ImportRes
                 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_safe and service.service_owner_safe != service.safe_address:
+        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_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_safe)
-                 logger.info(f"Imported Owner Safe {service.service_owner_safe}")
+                 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."""
@@ -971,7 +976,8 @@ def _import_service_config(self, service: DiscoveredService) -> Tuple[bool, str]
                 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),
             )

src/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):
+        """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)."""

src/iwa/plugins/olas/plugin.py

@@ -192,19 +192,19 @@ def _add_owner_info(self, table, service) -> None:
                  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_address and service.service_owner_address != service.service_owner_safe:
-             # Fallback if we have an address but no key object, and it's not the safe
-             table.add_row("Owner (EOA)", service.service_owner_address)
+        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_safe:
+        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_safe, service.chain_name
+                service.service_owner_multisig_address, service.chain_name
             )
-            val = service.service_owner_safe
+            val = service.service_owner_multisig_address
             if safe_exists:
                 val += " [green]✓[/green]"