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

iwa/core/chain/manager.py

@@ -0,0 +1,38 @@
+"""ChainInterfaces manager singleton."""
+
+from typing import Dict
+
+from iwa.core.chain.interface import ChainInterface
+from iwa.core.chain.models import Base, Ethereum, Gnosis
+from iwa.core.utils import singleton
+
+
+@singleton
+class ChainInterfaces:
+    """ChainInterfaces"""
+
+    gnosis: ChainInterface = ChainInterface(Gnosis())
+    ethereum: ChainInterface = ChainInterface(Ethereum())
+    base: ChainInterface = ChainInterface(Base())
+
+    def get(self, chain_name: str) -> ChainInterface:
+        """Get ChainInterface by chain name"""
+        chain_name = chain_name.strip().lower()
+
+        if not hasattr(self, chain_name):
+            raise ValueError(f"Unsupported chain: {chain_name}")
+
+        return getattr(self, chain_name)
+
+    def items(self):
+        """Iterate over all chain interfaces."""
+        yield "gnosis", self.gnosis
+        yield "ethereum", self.ethereum
+        yield "base", self.base
+
+    def check_all_rpcs(self) -> Dict[str, bool]:
+        """Check health of all chain RPCs."""
+        results = {}
+        for name, interface in self.items():
+            results[name] = interface.check_rpc_health()
+        return results

iwa/core/chain/models.py

@@ -0,0 +1,128 @@
+"""Chain model definitions."""
+
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel
+
+from iwa.core.models import EthereumAddress
+from iwa.core.settings import settings
+from iwa.core.utils import singleton
+
+
+class SupportedChain(BaseModel):
+    """SupportedChain"""
+
+    name: str
+    rpcs: List[str]
+    chain_id: int
+    native_currency: str
+    tokens: Dict[str, EthereumAddress] = {}
+    contracts: Dict[str, EthereumAddress] = {}
+
+    @property
+    def rpc(self) -> str:
+        """Get the primary RPC URL."""
+        return self.rpcs[0] if self.rpcs else ""
+
+    def get_token_address(self, token_address_or_name: str) -> Optional[EthereumAddress]:
+        """Get token address"""
+        try:
+            address = EthereumAddress(token_address_or_name)
+        except Exception:
+            address = None
+
+        if address and address in self.tokens.values():
+            return address
+
+        if address is None:
+            return self.tokens.get(token_address_or_name, None)
+
+        return None
+
+    def get_token_name(self, token_address: str) -> Optional[str]:
+        """Get token name from address."""
+        addr_lower = token_address.lower()
+        for name, addr in self.tokens.items():
+            if addr.lower() == addr_lower:
+                return name
+        return None
+
+
+@singleton
+class Gnosis(SupportedChain):
+    """Gnosis Chain"""
+
+    name: str = "Gnosis"
+    rpcs: List[str] = []  # Set dynamically in __init__
+    chain_id: int = 100
+    native_currency: str = "xDAI"
+    tokens: Dict[str, EthereumAddress] = {
+        "OLAS": EthereumAddress("0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f"),
+        "WXDAI": EthereumAddress("0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d"),
+        "USDC": EthereumAddress("0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0"),
+        "SDAI": EthereumAddress("0xaf204776c7245bF4147c2612BF6e5972Ee483701"),
+        "EURE": EthereumAddress("0xcB444e90D8198415266c6a2724b7900fb12FC56E"),
+    }
+    contracts: Dict[str, EthereumAddress] = {
+        "GNOSIS_SAFE_MULTISIG_IMPLEMENTATION": EthereumAddress(
+            "0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE"
+        ),
+        "GNOSIS_SAFE_FALLBACK_HANDLER": EthereumAddress(
+            "0xf48f2b2d2a534e402487b3ee7c18c33aec0fe5e4"
+        ),
+    }
+
+    def __init__(self, **data):
+        """Initialize with RPCs from settings (after testing override is applied)."""
+        super().__init__(**data)
+        if not self.rpcs and settings.gnosis_rpc:
+            self.rpcs = settings.gnosis_rpc.get_secret_value().split(",")
+
+
+@singleton
+class Ethereum(SupportedChain):
+    """Ethereum Mainnet"""
+
+    name: str = "Ethereum"
+    rpcs: List[str] = []  # Set dynamically in __init__
+    chain_id: int = 1
+    native_currency: str = "ETH"
+    tokens: Dict[str, EthereumAddress] = {
+        "OLAS": EthereumAddress("0x0001A500A6B18995B03f44bb040A5fFc28E45CB0"),
+    }
+    contracts: Dict[str, EthereumAddress] = {}
+
+    def __init__(self, **data):
+        """Initialize with RPCs from settings (after testing override is applied)."""
+        super().__init__(**data)
+        if not self.rpcs and settings.ethereum_rpc:
+            self.rpcs = settings.ethereum_rpc.get_secret_value().split(",")
+
+
+@singleton
+class Base(SupportedChain):
+    """Base"""
+
+    name: str = "Base"
+    rpcs: List[str] = []  # Set dynamically in __init__
+    chain_id: int = 8453
+    native_currency: str = "ETH"
+    tokens: Dict[str, EthereumAddress] = {
+        "OLAS": EthereumAddress("0x54330d28ca3357F294334BDC454a032e7f353416"),
+    }
+    contracts: Dict[str, EthereumAddress] = {}
+
+    def __init__(self, **data):
+        """Initialize with RPCs from settings (after testing override is applied)."""
+        super().__init__(**data)
+        if not self.rpcs and settings.base_rpc:
+            self.rpcs = settings.base_rpc.get_secret_value().split(",")
+
+
+@singleton
+class SupportedChains:
+    """SupportedChains"""
+
+    gnosis: SupportedChain = Gnosis()
+    ethereum: SupportedChain = Ethereum()
+    base: SupportedChain = Base()

iwa/core/chain/rate_limiter.py

@@ -0,0 +1,193 @@
+"""RPC rate limiting classes for chain interactions."""
+
+import threading
+import time
+from typing import TYPE_CHECKING, Dict
+
+from iwa.core.utils import configure_logger
+
+if TYPE_CHECKING:
+    from iwa.core.chain.interface import ChainInterface
+
+logger = configure_logger()
+
+
+class RPCRateLimiter:
+    """Token bucket rate limiter for RPC calls.
+
+    Uses a token bucket algorithm that allows bursts while maintaining
+    a maximum average rate over time.
+    """
+
+    DEFAULT_RATE = 25.0
+    DEFAULT_BURST = 50
+
+    def __init__(
+        self,
+        rate: float = DEFAULT_RATE,
+        burst: int = DEFAULT_BURST,
+    ):
+        """Initialize rate limiter.
+
+        Args:
+            rate: Maximum requests per second (refill rate)
+            burst: Maximum tokens (bucket size)
+
+        """
+        self.rate = rate
+        self.burst = burst
+        self.tokens = float(burst)
+        self.last_update = time.monotonic()
+        self._lock = threading.Lock()
+        self._backoff_until = 0.0
+
+    def acquire(self, timeout: float = 30.0) -> bool:
+        """Acquire a token, blocking if necessary."""
+        deadline = time.monotonic() + timeout
+
+        while True:
+            with self._lock:
+                now = time.monotonic()
+
+                if now < self._backoff_until:
+                    wait_time = self._backoff_until - now
+                    if now + wait_time > deadline:
+                        return False
+                else:
+                    elapsed = now - self.last_update
+                    self.tokens = min(self.burst, self.tokens + elapsed * self.rate)
+                    self.last_update = now
+
+                    if self.tokens >= 1.0:
+                        self.tokens -= 1.0
+                        return True
+
+                    wait_time = (1.0 - self.tokens) / self.rate
+                    if now + wait_time > deadline:
+                        return False
+
+            time.sleep(min(wait_time, 0.1))
+
+    def trigger_backoff(self, seconds: float = 5.0):
+        """Trigger rate limit backoff."""
+        with self._lock:
+            self._backoff_until = time.monotonic() + seconds
+            self.tokens = 0
+            logger.warning(f"RPC rate limit triggered, backing off for {seconds}s")
+
+    def get_status(self) -> dict:
+        """Get current rate limiter status."""
+        with self._lock:
+            now = time.monotonic()
+            in_backoff = now < self._backoff_until
+            return {
+                "tokens": self.tokens,
+                "rate": self.rate,
+                "burst": self.burst,
+                "in_backoff": in_backoff,
+                "backoff_remaining": max(0, self._backoff_until - now) if in_backoff else 0,
+            }
+
+
+# Global rate limiters per chain
+_rate_limiters: Dict[str, RPCRateLimiter] = {}
+_rate_limiters_lock = threading.Lock()
+
+
+def get_rate_limiter(chain_name: str, rate: float = None, burst: int = None) -> RPCRateLimiter:
+    """Get or create a rate limiter for a chain."""
+    with _rate_limiters_lock:
+        if chain_name not in _rate_limiters:
+            _rate_limiters[chain_name] = RPCRateLimiter(
+                rate=rate or RPCRateLimiter.DEFAULT_RATE,
+                burst=burst or RPCRateLimiter.DEFAULT_BURST,
+            )
+        return _rate_limiters[chain_name]
+
+
+class RateLimitedEth:
+    """Wrapper around web3.eth that applies rate limiting transparently."""
+
+    RPC_METHODS = {
+        "get_balance",
+        "get_code",
+        "get_transaction_count",
+        "estimate_gas",
+        "send_raw_transaction",
+        "wait_for_transaction_receipt",
+        "get_block",
+        "get_transaction",
+        "get_transaction_receipt",
+        "call",
+        "get_logs",
+    }
+
+    def __init__(self, web3_eth, rate_limiter: RPCRateLimiter, chain_interface: "ChainInterface"):
+        """Initialize RateLimitedEth wrapper."""
+        object.__setattr__(self, "_eth", web3_eth)
+        object.__setattr__(self, "_rate_limiter", rate_limiter)
+        object.__setattr__(self, "_chain_interface", chain_interface)
+
+    def __getattr__(self, name):
+        """Get attribute from underlying eth, wrapping RPC methods with rate limiting."""
+        attr = getattr(self._eth, name)
+
+        if name in self.RPC_METHODS and callable(attr):
+            return self._wrap_with_rate_limit(attr, name)
+
+        return attr
+
+    def __setattr__(self, name, value):
+        """Set attribute on underlying eth for test mocking."""
+        if name.startswith("_"):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._eth, name, value)
+
+    def __delattr__(self, name):
+        """Delete attribute from underlying eth for patch.object cleanup."""
+        if name.startswith("_"):
+            object.__delattr__(self, name)
+        else:
+            delattr(self._eth, name)
+
+    def _wrap_with_rate_limit(self, method, method_name):
+        """Wrap a method with rate limiting and error handling."""
+
+        def wrapper(*args, **kwargs):
+            if not self._rate_limiter.acquire(timeout=30.0):
+                raise TimeoutError(f"Rate limit timeout waiting for {method_name}")
+
+            try:
+                return method(*args, **kwargs)
+            except Exception as e:
+                self._chain_interface._handle_rpc_error(e)
+                raise
+
+        return wrapper
+
+
+class RateLimitedWeb3:
+    """Wrapper around Web3 instance that applies rate limiting transparently."""
+
+    def __init__(
+        self, web3_instance, rate_limiter: RPCRateLimiter, chain_interface: "ChainInterface"
+    ):
+        """Initialize RateLimitedWeb3 wrapper."""
+        self._web3 = web3_instance
+        self._rate_limiter = rate_limiter
+        self._chain_interface = chain_interface
+        self._eth_wrapper = None
+
+    @property
+    def eth(self):
+        """Return rate-limited eth interface."""
+        if self._eth_wrapper is None:
+            self._eth_wrapper = RateLimitedEth(
+                self._web3.eth, self._rate_limiter, self._chain_interface
+            )
+        return self._eth_wrapper
+
+    def __getattr__(self, name):
+        """Delegate attribute access to underlying Web3 instance."""
+        return getattr(self._web3, name)

iwa/core/cli.py

@@ -0,0 +1,210 @@
+"""CLI"""
+
+from typing import Optional
+
+import typer
+from web3 import Web3
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.keys import KeyStorage
+from iwa.core.services import PluginService
+from iwa.core.tables import list_accounts
+from iwa.core.wallet import Wallet
+from iwa.tui.app import IwaApp
+
+iwa_cli = typer.Typer(help="iwa command line interface")
+wallet_cli = typer.Typer(help="Manage wallet")
+
+iwa_cli.add_typer(wallet_cli, name="wallet")
+
+
+@wallet_cli.command("create")
+def account_create(
+    tag: Optional[str] = typer.Option(
+        None,
+        "--tag",
+        "-t",
+        help="Tag for this account",
+    ),
+):
+    """Create a new wallet account"""
+    key_storage = KeyStorage()
+    try:
+        key_storage.create_account(tag)
+    except ValueError as e:
+        typer.echo(f"Error: {e}")
+        raise typer.Exit(code=1) from e
+
+
+@wallet_cli.command("list")
+def account_list(
+    chain_name: Optional[str] = typer.Option(
+        "gnosis",
+        "--chain",
+        "-c",
+        help="Chain to retrieve balances from.",
+    ),
+    balances: Optional[str] = typer.Option(
+        None,
+        "--balances",
+        "-b",
+        help="Comma-separated list of token names to fetch balances for. Use 'native' for native currency.",
+    ),
+):
+    """List wallet accounts"""
+    wallet = Wallet()
+    chain_interface = ChainInterfaces().get(chain_name)
+    token_names_list = balances.split(",") if balances else []
+
+    accounts_data, token_balances = wallet.get_accounts_balances(chain_name, token_names_list)
+
+    list_accounts(
+        accounts_data,
+        chain_interface,
+        token_names_list,
+        token_balances,
+    )
+
+
+@wallet_cli.command("send")
+def account_send(
+    from_address_or_tag: str = typer.Option(..., "--from", "-f", help="From address or tag"),
+    to_address_or_tag: str = typer.Option(..., "--to", "-t", help="To address or tag"),
+    token_address_or_name: str = typer.Option(
+        NATIVE_CURRENCY_ADDRESS,
+        "--token",
+        "-k",
+        help="ERC20 token contract address, ignore for native",
+    ),
+    amount_eth: float = typer.Option(..., "--amount", "-a", help="Amount to send, in ether"),
+    chain: str = typer.Option(
+        "gnosis",
+        "--chain",
+        help="Chain to send from",
+    ),
+):
+    """Send native currency or ERC20 tokens to an address"""
+    wallet = Wallet()
+    wallet.send(
+        from_address_or_tag=from_address_or_tag,
+        to_address_or_tag=to_address_or_tag,
+        token_address_or_name=token_address_or_name,
+        amount_wei=Web3.to_wei(amount_eth, "ether"),
+        chain_name=chain,
+    )
+
+
+@wallet_cli.command("transfer-from")
+def erc20_transfer_from(
+    from_address_or_tag: str = typer.Option(..., "--from", "-f", help="From address or tag"),
+    sender_address_or_tag: str = typer.Option(..., "--sender", "-s", help="Sender address or tag"),
+    recipient_address_or_tag: str = typer.Option(
+        ..., "--recipient", "-r", help="Recipient address or tag"
+    ),
+    token_address_or_name: str = typer.Option(
+        ..., "--token", "-k", help="ERC20 token contract address"
+    ),
+    amount_eth: float = typer.Option(..., "--amount", "-a", help="Amount to transfer, in ether"),
+    chain: str = typer.Option(
+        "gnosis",
+        "--chain",
+        help="Chain to send from",
+    ),
+):
+    """Transfer ERC20 tokens from a sender to a recipient using allowance"""
+    wallet = Wallet()
+    wallet.transfer_from_erc20(
+        from_address_or_tag=from_address_or_tag,
+        sender_address_or_tag=sender_address_or_tag,
+        recipient_address_or_tag=recipient_address_or_tag,
+        token_address_or_name=token_address_or_name,
+        amount_wei=Web3.to_wei(amount_eth, "ether"),
+        chain_name=chain,
+    )
+
+
+@wallet_cli.command("approve")
+def erc20_approve(
+    owner_address_or_tag: str = typer.Option(..., "--owner", "-f", help="Owner address or tag"),
+    spender_address_or_tag: str = typer.Option(
+        ..., "--spender", "-t", help="Spender address or tag"
+    ),
+    token_address_or_name: str = typer.Option(
+        ..., "--token", "-k", help="ERC20 token contract address"
+    ),
+    amount_eth: float = typer.Option(..., "--amount", "-a", help="Amount to approve, in ether"),
+    chain: str = typer.Option(
+        "gnosis",
+        "--chain",
+        help="Chain to send from",
+    ),
+):
+    """Approve ERC20 token allowance for a spender"""
+    wallet = Wallet()
+    wallet.approve_erc20(
+        owner_address_or_tag=owner_address_or_tag,
+        spender_address_or_tag=spender_address_or_tag,
+        token_address_or_name=token_address_or_name,
+        amount_wei=Web3.to_wei(amount_eth, "ether"),
+        chain_name=chain,
+    )
+
+
+@iwa_cli.command("tui")
+def tui():
+    """Start Terminal User Interface."""
+    app = IwaApp()
+    app.run()
+
+
+@iwa_cli.command("web")
+def web_server(
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="Port to listen on"),
+    host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host to listen on"),
+):
+    """Start Web Interface."""
+    from iwa.core.settings import settings
+    from iwa.web.server import run_server
+
+    server_port = port or settings.web_port
+    typer.echo(f"Starting web server on http://{host}:{server_port}")
+    run_server(host=host, port=server_port)
+
+
+@wallet_cli.command("drain")
+def drain_wallet(
+    from_address_or_tag: str = typer.Option(..., "--from", "-f", help="From address or tag"),
+    to_address_or_tag: str = typer.Option(..., "--to", "-t", help="To address or tag"),
+    chain_name: str = typer.Option(
+        "gnosis",
+        "--chain",
+        "-c",
+        help="Chain to drain from.",
+    ),
+):
+    """Drain all tokens and native currency from one wallet to another"""
+    wallet = Wallet()
+    wallet.drain(
+        from_address_or_tag=from_address_or_tag,
+        to_address_or_tag=to_address_or_tag,
+        chain_name=chain_name,
+    )
+
+
+# Load Plugins
+# Removed direct import here, moved to top
+
+plugin_service = PluginService()
+plugins = plugin_service.get_all_plugins()
+
+for plugin_name, plugin in plugins.items():
+    commands = plugin.get_cli_commands()
+    if commands:
+        plugin_app = typer.Typer(help=f"{plugin_name} commands")
+        for cmd_name, cmd_func in commands.items():
+            plugin_app.command(name=cmd_name)(cmd_func)
+        iwa_cli.add_typer(plugin_app, name=plugin_name)
+
+if __name__ == "__main__":  # pragma: no cover
+    iwa_cli()

iwa/core/constants.py

@@ -0,0 +1,28 @@
+"""Core constants"""
+
+from pathlib import Path
+
+from iwa.core.types import EthereumAddress
+
+PROJECT_ROOT = Path(__file__).parent.parent.parent.parent
+
+# Data directory for sensitive/runtime files
+DATA_DIR = PROJECT_ROOT / "data"
+
+SECRETS_PATH = DATA_DIR / "secrets.env"
+CONFIG_PATH = DATA_DIR / "config.yaml"
+WALLET_PATH = DATA_DIR / "wallet.json"
+BACKUP_DIR = DATA_DIR / "backup"
+TENDERLY_CONFIG_PATH = PROJECT_ROOT / "tenderly.yaml"
+
+ABI_PATH = PROJECT_ROOT / "src" / "iwa" / "core" / "contracts" / "abis"
+
+# Standard Ethereum addresses
+ZERO_ADDRESS = EthereumAddress("0x0000000000000000000000000000000000000000")
+NATIVE_CURRENCY_ADDRESS = EthereumAddress("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")
+DEFAULT_MECH_CONTRACT_ADDRESS = EthereumAddress("0x77af31De935740567Cf4FF1986D04B2c964A786a")
+
+
+def get_tenderly_config_path(profile: int = 1) -> Path:
+    """Get the path to a profile-specific Tenderly config file."""
+    return PROJECT_ROOT / f"tenderly_{profile}.yaml"

iwa/core/contracts/__init__.py

@@ -0,0 +1 @@
+"""iwa.core.contracts package."""