iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

iwa/core/models.py

@@ -0,0 +1,344 @@
+"""Core models"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Type, TypeVar
+
+import tomli
+import tomli_w
+import yaml
+from pydantic import BaseModel, Field, PrivateAttr
+from pydantic_core import core_schema
+
+from iwa.core.types import EthereumAddress  # noqa: F401 - re-exported for backwards compatibility
+from iwa.core.utils import singleton
+
+
+class StoredAccount(BaseModel):
+    """StoredAccount representing an EOA or contract account."""
+
+    address: EthereumAddress = Field(description="Ethereum address (checksummed)")
+    tag: str = Field(description="Human-readable alias for the account")
+
+
+class StoredSafeAccount(StoredAccount):
+    """StoredSafeAccount representing a Gnosis Safe."""
+
+    signers: List[EthereumAddress] = Field(description="List of owner addresses")
+    threshold: int = Field(description="Required signatures threshold")
+    chains: List[str] = Field(description="List of supported chains")
+
+
+class CoreConfig(BaseModel):
+    """Core configuration settings."""
+
+    manual_claim_enabled: bool = Field(
+        default=False, description="Enable manual claiming of rewards"
+    )
+    request_activity_alert_enabled: bool = Field(
+        default=True, description="Enable alerts for suspicious activity"
+    )
+    whitelist: Dict[str, EthereumAddress] = Field(
+        default_factory=dict, description="Address whitelist for security"
+    )
+    custom_tokens: Dict[str, Dict[str, EthereumAddress]] = Field(
+        default_factory=dict, description="Custom token definitions per chain"
+    )
+
+
+T = TypeVar("T", bound="StorableModel")
+
+
+class StorableModel(BaseModel):
+    """StorableModel with load and save methods for JSON, TOML, and YAML formats."""
+
+    _storage_format: Optional[str] = PrivateAttr(default=None)
+    _path: Optional[Path] = PrivateAttr()
+
+    def save_json(self, path: Optional[Path] = None, **kwargs) -> None:
+        """Save to JSON file"""
+        if path is None:
+            if getattr(self, "_path", None) is None:
+                raise ValueError("Save path not specified and no previous path stored.")
+            path = self._path
+
+        path = path.with_suffix(".json")
+
+        with path.open("w", encoding="utf-8") as f:
+            json.dump(self.model_dump(), f, indent=2, ensure_ascii=False, **kwargs)
+        self._storage_format = "json"
+        self._path = path
+
+    def save_toml(self, path: Optional[Path] = None) -> None:
+        """Save to TOML file"""
+        if path is None:
+            if getattr(self, "_path", None) is None:
+                raise ValueError("Save path not specified and no previous path stored.")
+            path = self._path
+
+        path = path.with_suffix(".toml")
+
+        with path.open("wb") as f:
+            tomli_w.dump(self.model_dump(exclude_none=True), f)
+        self._storage_format = "toml"
+        self._path = path
+
+    def save_yaml(self, path: Optional[Path] = None) -> None:
+        """Save to YAML file"""
+        if path is None:
+            if getattr(self, "_path", None) is None:
+                raise ValueError("Save path not specified and no previous path stored.")
+            path = self._path
+
+        path = path.with_suffix(".yaml")
+
+        with path.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(self.model_dump(), f, sort_keys=False, allow_unicode=True)
+        self._storage_format = "yaml"
+        self._path = path
+
+    def save(self, path: str | Path | None = None, **kwargs) -> None:
+        """Save to file with specified format"""
+        if path is None:
+            if getattr(self, "_path", None) is None:
+                raise ValueError("Save path not specified and no previous path stored.")
+            path = self._path
+
+        path = Path(path)
+        ext = path.suffix.lower()
+        if ext == ".json":
+            self.save_json(path, **kwargs)
+        elif ext in {".toml", ".tml"}:
+            self.save_toml(path)
+        elif ext in {".yaml", ".yml"}:
+            self.save_yaml(path)
+        else:
+            sf = (self._storage_format or "").lower()
+            if sf == "json":
+                self.save_json(path, **kwargs)
+            elif sf in {"toml", "tml"}:
+                self.save_toml(path)
+            elif sf in {"yaml", "yml"}:
+                self.save_yaml(path)
+            else:
+                raise ValueError(f"Extension not supported: {ext}")
+
+    @classmethod
+    def load_json(cls: Type[T], path: str | Path) -> T:
+        """Load from JSON file"""
+        path = Path(path)
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        obj = cls(**data)
+        obj._storage_format = "json"
+        obj._path = path
+        return obj
+
+    @classmethod
+    def load_toml(cls: Type[T], path: str | Path) -> T:
+        """Load from TOML file"""
+        path = Path(path)
+        with path.open("rb") as f:
+            data = tomli.load(f)
+        obj = cls(**data)
+        obj._storage_format = "toml"
+        obj._path = path
+        return obj
+
+    @classmethod
+    def load_yaml(cls: Type[T], path: str | Path) -> T:
+        """Load from YAML file"""
+        path = Path(path)
+        with path.open("r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        obj = cls(**data)
+        obj._storage_format = "yaml"
+        obj._path = path
+        return obj
+
+    @classmethod
+    def load(cls: Type[T], path: Path) -> T:
+        """Load from file with specified format"""
+        extension = path.suffix.lower()
+        if extension == ".json":
+            return cls.load_json(path)
+        elif extension in {".toml", ".tml"}:
+            return cls.load_toml(path)
+        elif extension in {".yaml", ".yml"}:
+            return cls.load_yaml(path)
+        else:
+            raise ValueError(f"Unsupported file extension: {extension}")
+
+
+@singleton
+class Config(StorableModel):
+    """Config with auto-loading and plugin support."""
+
+    core: Optional[CoreConfig] = None
+    plugins: Dict[str, BaseModel] = Field(default_factory=dict)
+
+    _initialized: bool = PrivateAttr(default=False)
+    _plugin_models: Dict[str, type] = PrivateAttr(default_factory=dict)
+
+    def model_post_init(self, __context) -> None:
+        """Load config from file after initialization."""
+        if not self._initialized:
+            self._try_load()
+            self._initialized = True
+
+    def _try_load(self) -> None:
+        """Try to load from config.yaml if exists, otherwise create default."""
+        from loguru import logger
+
+        from iwa.core.constants import CONFIG_PATH
+
+        if not CONFIG_PATH.exists():
+            # Initialize default core config and save
+            self.core = CoreConfig()
+            CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+            self.save_yaml(CONFIG_PATH)
+            logger.info(f"Created default config file: {CONFIG_PATH}")
+            return
+
+        try:
+            import yaml
+
+            with CONFIG_PATH.open("r", encoding="utf-8") as f:
+                data = yaml.safe_load(f) or {}
+
+            # Load core config
+            if "core" in data:
+                self.core = CoreConfig(**data["core"])
+
+            # Load plugin configs - will be hydrated when plugins register
+            if "plugins" in data:
+                for plugin_name, plugin_data in data["plugins"].items():
+                    # Store raw data until plugin model is registered
+                    if plugin_name in self._plugin_models:
+                        self.plugins[plugin_name] = self._plugin_models[plugin_name](**plugin_data)
+                    else:
+                        # Store as dict temporarily, will hydrate on register
+                        self.plugins[plugin_name] = plugin_data
+
+            self._path = CONFIG_PATH
+            self._storage_format = "yaml"
+        except Exception as e:
+            logger.warning(f"Failed to load config from {CONFIG_PATH}: {e}")
+
+        # Ensure core config always exists
+        if self.core is None:
+            self.core = CoreConfig()
+
+    def register_plugin_config(self, plugin_name: str, model_class: type) -> None:
+        """Register a plugin's config model class.
+
+        If raw data was loaded for this plugin, it will be hydrated into the model.
+        If no data exists, creates default config and persists to file.
+        """
+        self._plugin_models[plugin_name] = model_class
+
+        # Hydrate any raw data that was loaded
+        if plugin_name in self.plugins:
+            current = self.plugins[plugin_name]
+            if isinstance(current, dict):
+                self.plugins[plugin_name] = model_class(**current)
+        else:
+            # Create default config for plugin and persist
+            self.plugins[plugin_name] = model_class()
+            self.save_config()
+
+    def save_config(self) -> None:
+        """Persist current config to config.yaml."""
+        import yaml
+
+        from iwa.core.constants import CONFIG_PATH
+
+        data = {}
+
+        if self.core:
+            data["core"] = self.core.model_dump()
+
+        data["plugins"] = {}
+        for plugin_name, plugin_config in self.plugins.items():
+            if isinstance(plugin_config, BaseModel):
+                data["plugins"][plugin_name] = plugin_config.model_dump()
+            elif isinstance(plugin_config, dict):
+                data["plugins"][plugin_name] = plugin_config
+
+        with CONFIG_PATH.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(data, f, sort_keys=False, allow_unicode=True, default_flow_style=False)
+
+        self._path = CONFIG_PATH
+        self._storage_format = "yaml"
+
+    def get_plugin_config(self, plugin_name: str) -> Optional[BaseModel]:
+        """Get a plugin's configuration."""
+        return self.plugins.get(plugin_name)
+
+
+class Token(BaseModel):
+    """Token model for defined tokens."""
+
+    symbol: str
+    address: EthereumAddress
+    decimals: int = 18
+    name: Optional[str] = None
+
+
+class TokenAmount(BaseModel):
+    """TokenAmount - amount in human-readable ETH units."""
+
+    address: EthereumAddress
+    symbol: str
+    amount_eth: float
+
+
+class FundRequirements(BaseModel):
+    """FundRequirements - amounts in human-readable ETH units."""
+
+    native_eth: float
+    tokens: List[TokenAmount] = Field(default_factory=list)
+
+
+class VirtualNet(BaseModel):
+    """Virtual Network configuration for Tenderly."""
+
+    vnet_id: Optional[str] = Field(default=None, description="Tenderly Virtual TestNet ID")
+    chain_id: int = Field(description="Chain ID of the forked network")
+    vnet_slug: Optional[str] = Field(default=None, description="Slug for the Virtual TestNet")
+    vnet_display_name: Optional[str] = Field(default=None, description="Display name for UI")
+    funds_requirements: Dict[str, FundRequirements] = Field(
+        description="Required funds for test accounts"
+    )
+    admin_rpc: Optional[str] = Field(default=None, description="Admin RPC URL for the vNet")
+    public_rpc: Optional[str] = Field(default=None, description="Public RPC URL for the vNet")
+    initial_block: int = Field(default=0, description="Block number at vNet creation")
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source, _handler):
+        """Get the Pydantic core schema for VirtualNet."""
+        return core_schema.with_info_after_validator_function(
+            cls.validate,
+            _handler(_source),
+        )
+
+    @classmethod
+    def validate(cls, value: "VirtualNet", _info) -> "VirtualNet":
+        """Validate RPC URLs."""
+        if value.admin_rpc and not (
+            value.admin_rpc.startswith("http://") or value.admin_rpc.startswith("https://")
+        ):
+            raise ValueError(f"Invalid admin_rpc URL: {value.admin_rpc}")
+        if value.public_rpc and not (
+            value.public_rpc.startswith("http://") or value.public_rpc.startswith("https://")
+        ):
+            raise ValueError(f"Invalid public_rpc URL: {value.public_rpc}")
+        return value
+
+
+class TenderlyConfig(StorableModel):
+    """Configuration for Tenderly integration."""
+
+    vnets: Dict[str, VirtualNet] = Field(
+        description="Map of chain names to VirtualNet configurations"
+    )

iwa/core/monitor.py

@@ -0,0 +1,209 @@
+"""Event Monitor for Iwa TUI"""
+
+import time
+from typing import Any, Callable, Dict, List
+
+from web3 import Web3
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.utils import configure_logger
+
+logger = configure_logger()
+
+
+class EventMonitor:
+    """Monitors chain for events affecting specific addresses."""
+
+    def __init__(
+        self, addresses: List[str], callback: Callable, chain_name: str = "gnosis"
+    ) -> None:
+        """Initialize events monitor."""
+        self.chain_name = chain_name
+        self.addresses = [Web3.to_checksum_address(addr) for addr in addresses]
+        self.callback = callback
+        self.chain_interface = ChainInterfaces().get(chain_name)
+        self.web3 = self.chain_interface.web3
+        self.running = False
+        if self.chain_interface.chain.rpc:
+            try:
+                self.last_checked_block = self.web3.eth.block_number
+            except Exception:
+                self.last_checked_block = 0
+        else:
+            self.last_checked_block = 0
+
+    def start(self):
+        """Start monitoring loop."""
+        self.running = True
+        logger.info(
+            f"Starting EventMonitor for {len(self.addresses)} addresses on {self.chain_interface.chain.name}"
+        )
+
+        if not self.chain_interface.chain.rpc:
+            logger.error(
+                f"Cannot start EventMonitor: No RPC URL found for chain {self.chain_interface.chain.name}"
+            )
+            self.running = False
+            return
+
+        logger.info(f"Monitoring addresses: {self.addresses}")
+
+        while self.running:
+            try:
+                self.check_activity()
+            except Exception as e:
+                logger.error(f"Error in EventMonitor: {e}")
+
+            time.sleep(6)
+
+    def stop(self):
+        """Stop monitoring."""
+        self.running = False
+
+    def check_activity(self):
+        """Check for new blocks and logs."""
+        try:
+            latest_block = self.web3.eth.block_number
+        except Exception as e:
+            logger.error(f"Failed to get block number: {e}")
+            return
+
+        if not self._should_check(latest_block):
+            return
+
+        logger.info(f"New block detected: {latest_block} (Last: {self.last_checked_block})")
+
+        from_block, to_block = self._get_block_range(latest_block)
+
+        found_txs = []
+        found_txs.extend(self._check_native_transfers(from_block, to_block))
+        found_txs.extend(self._check_erc20_transfers(from_block, to_block))
+
+        self.last_checked_block = to_block
+
+        if found_txs:
+            self.callback(found_txs)
+
+    def _should_check(self, latest_block: int) -> bool:
+        return latest_block > self.last_checked_block
+
+    def _get_block_range(self, latest_block: int) -> tuple[int, int]:
+        from_block = self.last_checked_block + 1
+        to_block = latest_block
+
+        if to_block - from_block > 100:
+            from_block = to_block - 100
+        return from_block, to_block
+
+    def _check_native_transfers(self, from_block: int, to_block: int) -> List[Dict[str, Any]]:
+        found_txs = []
+        my_addrs = set(a.lower() for a in self.addresses)
+
+        for block_num in range(from_block, to_block + 1):
+            try:
+                block = self.web3.eth.get_block(block_num, full_transactions=True)
+                for tx in block.transactions:
+                    # Handle case where RPC returns hash despite full_transactions=True
+                    if isinstance(tx, (str, bytes)):
+                        logger.debug(f"Got tx hash {tx}, fetching details...")
+                        tx = self.web3.eth.get_transaction(tx)
+
+                    # Normalize tx addresses to lower, handling None for contract creation
+                    tx_from = tx.get("from", "").lower() if tx.get("from") else None
+                    tx_to = tx.get("to", "").lower() if tx.get("to") else None
+
+                    if (tx_from and tx_from in my_addrs) or (tx_to and tx_to in my_addrs):
+                        logger.info(
+                            f"Native activity detected in block {block_num} tx {tx['hash'].hex()}"
+                        )
+                        found_txs.append(
+                            {
+                                "hash": tx["hash"].hex(),
+                                # Use original checksummed 'from' if available in tx, or re-checksum
+                                "from": Web3.to_checksum_address(tx_from) if tx_from else None,
+                                "to": Web3.to_checksum_address(tx_to) if tx_to else None,
+                                "value": tx.get("value", 0),
+                                "token": "NATIVE",
+                                "timestamp": block.timestamp,
+                                "chain": self.chain_name,
+                            }
+                        )
+            except Exception as e:
+                logger.warning(f"Failed to fetch/process block {block_num}: {e}")
+
+        return found_txs
+
+    def _check_erc20_transfers(self, from_block: int, to_block: int) -> List[Dict[str, Any]]:
+        found_txs = []
+        my_addrs = set(a.lower() for a in self.addresses)
+
+        transfer_topic = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
+        padded_addresses = [
+            "0x000000000000000000000000" + addr.lower().replace("0x", "") for addr in self.addresses
+        ]
+
+        try:
+            # Efficiently Query 1: Transfers FROM our addresses (Topic 1)
+            logs_sent = self.web3.eth.get_logs(
+                {
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "topics": [transfer_topic, padded_addresses],
+                }
+            )
+
+            # Efficiently Query 2: Transfers TO our addresses (Topic 2)
+            logs_received = self.web3.eth.get_logs(
+                {
+                    "fromBlock": from_block,
+                    "toBlock": to_block,
+                    "topics": [transfer_topic, None, padded_addresses],
+                }
+            )
+
+            all_logs = logs_sent + logs_received
+
+            for log in all_logs:
+                if len(log["topics"]) < 3:
+                    continue
+                # topic[1] is from, topic[2] is to. (32 bytes)
+                t_from = "0x" + log["topics"][1].hex()[-40:]
+                t_to = "0x" + log["topics"][2].hex()[-40:]
+
+                # Check for uniqueness? Hash is unique key in UI anyway.
+
+                # Double check (though RPC filter should have ensured it)
+                t_from_lower = t_from.lower()
+                t_to_lower = t_to.lower()
+
+                is_related = False
+                for my_addr in my_addrs:
+                    if my_addr in t_from_lower or my_addr in t_to_lower:
+                        is_related = True
+                        break
+
+                if is_related:
+                    found_txs.append(
+                        {
+                            "hash": log["transactionHash"].hex(),
+                            "from": Web3.to_checksum_address(t_from),
+                            "to": Web3.to_checksum_address(t_to),
+                            "value": int(
+                                log["data"].hex()
+                                if isinstance(log["data"], bytes)
+                                else log["data"],
+                                16,
+                            )
+                            if log.get("data")
+                            else 0,
+                            "token": "TOKEN",
+                            "contract_address": log["address"],
+                            "timestamp": 0,  # Would require block fetch
+                            "chain": self.chain_name,
+                        }
+                    )
+
+        except Exception as e:
+            logger.warning(f"Failed to fetch logs: {e}")
+
+        return found_txs

iwa/core/plugins.py

@@ -0,0 +1,45 @@
+"""Plugin system architecture."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Dict, Optional, Type
+
+from pydantic import BaseModel
+
+from iwa.core.utils import configure_logger
+
+if TYPE_CHECKING:
+    from textual.widget import Widget
+
+logger = configure_logger()
+
+
+class Plugin(ABC):
+    """Abstract base class for plugins."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Plugin name."""
+        pass
+
+    @property
+    def version(self) -> str:
+        """Plugin version."""
+        return "0.1.0"
+
+    @property
+    def config_model(self) -> Optional[Type[BaseModel]]:
+        """Pydantic model for plugin configuration."""
+        return None
+
+    def get_cli_commands(self) -> Dict[str, callable]:
+        """Return a dict of command_name: function to registers in CLI."""
+        return {}
+
+    def on_load(self) -> None:  # noqa: B027
+        """Called when plugin is loaded."""
+        pass
+
+    def get_tui_view(self, wallet=None) -> Optional["Widget"]:
+        """Return a Textual Widget to be displayed in the TUI."""
+        return None

iwa/core/pricing.py

@@ -0,0 +1,91 @@
+"""Pricing service module."""
+
+import time
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+
+import requests
+from loguru import logger
+
+from iwa.core.settings import settings
+
+
+class PriceService:
+    """Service to fetch token prices from CoinGecko."""
+
+    BASE_URL = "https://api.coingecko.com/api/v3"
+
+    def __init__(self, cache_ttl_minutes: int = 5):
+        """Initialize PriceService."""
+        self.settings = settings
+        self.cache: Dict[str, Dict] = {}  # {id_currency: {"price": float, "timestamp": datetime}}
+        self.cache_ttl = timedelta(minutes=cache_ttl_minutes)
+        self.api_key = (
+            self.settings.coingecko_api_key.get_secret_value()
+            if self.settings.coingecko_api_key
+            else None
+        )
+
+    def get_token_price(self, token_id: str, vs_currency: str = "eur") -> Optional[float]:
+        """Get token price in specified currency.
+
+        Args:
+            token_id: CoinGecko token ID (e.g. 'ethereum', 'gnosis', 'olas')
+            vs_currency: Target currency (default 'eur')
+
+        Returns:
+            Price as float, or None if fetch failed.
+
+        """
+        cache_key = f"{token_id}_{vs_currency}"
+
+        # Check cache
+        if cache_key in self.cache:
+            entry = self.cache[cache_key]
+            if datetime.now() - entry["timestamp"] < self.cache_ttl:
+                return entry["price"]
+
+        # Fetch from API with 2 retries
+        max_retries = 2
+        for attempt in range(max_retries + 1):
+            try:
+                url = f"{self.BASE_URL}/simple/price"
+                params = {"ids": token_id, "vs_currencies": vs_currency}
+                headers = {}
+                if self.api_key:
+                    headers["x-cg-demo-api-key"] = self.api_key
+
+                response = requests.get(url, params=params, headers=headers, timeout=10)
+
+                if response.status_code == 429:
+                    logger.warning(
+                        f"CoinGecko rate limit reached (429) for {token_id}. Attempt {attempt + 1}/{max_retries + 1}"
+                    )
+                    if attempt < max_retries:
+                        time.sleep(2 * (attempt + 1))
+                        continue
+                    return None
+
+                response.raise_for_status()
+
+                data = response.json()
+                if token_id in data and vs_currency in data[token_id]:
+                    price = float(data[token_id][vs_currency])
+
+                    # Update cache
+                    self.cache[cache_key] = {"price": price, "timestamp": datetime.now()}
+                    return price
+                else:
+                    logger.warning(
+                        f"Price for {token_id} in {vs_currency} not found in response: {data}"
+                    )
+                    # Don't cache None, might be a temporary hiccup
+                    return None
+
+            except Exception as e:
+                logger.error(f"Failed to fetch price for {token_id} (Attempt {attempt + 1}): {e}")
+                if attempt < max_retries:
+                    time.sleep(1)
+                    continue
+                return None
+        return None