iwa 0.0.21__tar.gz → 0.0.24__tar.gz

{iwa-0.0.21/src/iwa.egg-info → iwa-0.0.24}/PKG-INFO

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

{iwa-0.0.21 → iwa-0.0.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.21"
+version = "0.0.24"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -71,7 +71,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.0.21"
+target-version = "0.0.24"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.21 → iwa-0.0.24}/src/iwa/plugins/olas/importer.py

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