iwa 0.0.27__tar.gz → 0.0.28__tar.gz

{iwa-0.0.27/src/iwa.egg-info → iwa-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.27
+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.27 → iwa-0.0.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.27"
+version = "0.0.28"
 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.27"
+target-version = "0.0.28"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.27 → iwa-0.0.28}/src/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-0.0.27 → iwa-0.0.28}/src/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-0.0.28/src/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-0.0.27 → iwa-0.0.28}/src/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-0.0.27 → iwa-0.0.28}/src/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-0.0.27 → iwa-0.0.28}/src/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-0.0.27 → iwa-0.0.28}/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):  # 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