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

iwa/core/tables.py

@@ -0,0 +1,60 @@
+"""Account storage protocol definitions"""
+
+from typing import Dict, List, Optional
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from iwa.core.chain import ChainInterface
+from iwa.core.models import StoredSafeAccount
+
+
+def list_accounts(
+    accounts: Optional[Dict],
+    chain_interface: ChainInterface,
+    token_names: Optional[List[str]],
+    token_balances: Optional[Dict],
+) -> None:
+    """List accounts"""
+    console = Console()
+    table = Table(
+        title="Accounts",
+        show_header=True,
+    )
+
+    table.add_column("Address", style="dim", width=42, justify="center")
+    table.add_column("Type", style="dim", width=10, justify="center")
+    table.add_column("Tag", style="dim", width=20, justify="center")
+
+    if token_names:
+        for token_name in token_names:
+            token = (
+                chain_interface.chain.native_currency
+                if token_name == "native"
+                else token_name.upper()
+            )
+            table.add_column(f"Balance {token}", style="dim", justify="center")
+
+    if accounts:
+        for acct in accounts.values():
+            acct_type = "Safe" if isinstance(acct, StoredSafeAccount) else "EOA"
+            tag_cell = Text(acct.tag, style="bold green")
+            args = (acct.address, acct_type, tag_cell)
+            if token_balances:
+                balances = token_balances.get(acct.address)
+                for token_name, token_balance in balances.items():
+                    token = (
+                        chain_interface.chain.native_currency
+                        if token_name == "native"
+                        else token_name.upper()
+                    )
+                    args += (f"{token_balance:.2f} {token}",)
+            table.add_row(*args)
+    else:
+        row_args = ("No accounts found", "-")
+        if token_balances:
+            row_args += tuple("-" for _ in token_balances)
+        table.add_row(*row_args)
+
+    console.print(table, justify="center")

iwa/core/test.py

@@ -0,0 +1,27 @@
+"""Test module."""
+
+import asyncio
+
+from iwa.core.wallet import Wallet
+from iwa.plugins.olas.service_manager import ServiceManager
+
+wallet = Wallet()
+
+
+async def main():
+    """Example of using CoW Swap on Gnosis Chain."""
+    # await wallet.swap_tokens(
+    #     account_address_or_tag="master",
+    #     amount_eth=None,  # Swap entire balance
+    #     sell_token_name="OLAS",
+    #     buy_token_name="SDAI",
+    #     chain_name="gnosis",
+    #     fixed_buy_amount=False,
+    # )
+
+    service_manager = ServiceManager(wallet=wallet)
+    service_manager.create()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    asyncio.run(main())

iwa/core/tests/test_wallet.py

@@ -0,0 +1,255 @@
+"""Tests for Wallet module."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from iwa.core.wallet import Wallet
+
+
+@pytest.fixture
+def mock_keys_and_services():
+    """Mock keys and services."""
+    with (
+        patch("iwa.core.wallet.KeyStorage") as mock_ks,
+        patch("iwa.core.wallet.AccountService") as mock_as,
+        patch("iwa.core.wallet.BalanceService") as mock_bs,
+        patch("iwa.core.wallet.SafeService") as mock_ss,
+        patch("iwa.core.wallet.TransactionService") as mock_ts,
+        patch("iwa.core.wallet.TransferService") as mock_trs,
+        patch("iwa.core.wallet.PluginService") as mock_ps,
+        patch("iwa.core.wallet.init_db") as mock_init_db,
+        patch("iwa.core.wallet.configure_logger"),
+    ):
+        yield {
+            "key_storage": mock_ks,
+            "account_service": mock_as,
+            "balance_service": mock_bs,
+            "safe_service": mock_ss,
+            "transaction_service": mock_ts,
+            "transfer_service": mock_trs,
+            "plugin_service": mock_ps,
+            "init_db": mock_init_db,
+        }
+
+
+@pytest.fixture
+def wallet(mock_keys_and_services):
+    """Wallet fixture."""
+    return Wallet()
+
+
+def test_init(mock_keys_and_services):
+    """Test initialization."""
+    wallet = Wallet()
+    assert wallet.key_storage == mock_keys_and_services["key_storage"].return_value
+    mock_keys_and_services["init_db"].assert_called_once()
+
+
+def test_master_account(wallet, mock_keys_and_services):
+    """Test master account property."""
+    # Accesses property on account_service instance
+
+
+def test_get_token_address(wallet, mock_keys_and_services):
+    """Test get_token_address."""
+    wallet.get_token_address("OLAS", "gnosis")
+    mock_keys_and_services["account_service"].return_value.get_token_address.assert_called_with(
+        "OLAS", "gnosis"
+    )
+
+
+def test_get_accounts_balances(wallet, mock_keys_and_services):
+    """Test get_accounts_balances."""
+    # Mock account data
+    mock_keys_and_services["account_service"].return_value.get_account_data.return_value = {
+        "0x1": {"tag": "one"},
+        "0x2": {"tag": "two"},
+    }
+
+    # Mock balance service
+    mock_bs = mock_keys_and_services["balance_service"].return_value
+    mock_bs.get_native_balance_eth.return_value = 1.0
+    mock_bs.get_erc20_balance_eth.return_value = 2.0
+
+    # Test with no token names
+    data, balances = wallet.get_accounts_balances("gnosis")
+    assert data == {"0x1": {"tag": "one"}, "0x2": {"tag": "two"}}
+    assert balances is None
+
+    # Test with token names
+    # Mock ThreadPoolExecutor to run synchronously or just return futures
+    # Since we can't easily suppress the real ThreadPoolExecutor context manager used in the code without patching it,
+    # let's patch it in the test function scope.
+
+    with patch("iwa.core.wallet.ThreadPoolExecutor") as mock_executor:
+        # returns context manager
+        mock_context = MagicMock()
+        mock_executor.return_value.__enter__.return_value = mock_context
+
+        # mock submit to return a future
+        mock_future1 = MagicMock()
+        mock_future1.result.return_value = ("0x1", "native", 1.0)
+
+        mock_future2 = MagicMock()
+        mock_future2.result.return_value = ("0x1", "OLAS", 2.0)
+
+        mock_context.submit.side_effect = [
+            mock_future1,
+            mock_future2,
+            mock_future1,
+            mock_future2,
+        ]  # Just cycling mocks
+
+        # We need to rely on what the code does: it iterates over accounts, then tokens.
+        # 2 accounts * 2 tokens = 4 calls.
+
+        # Simpler approach: let the real ThreadPoolExecutor run but mock the balance service methods which are already mocked.
+        # The issue is the code uses `fetch_balance` inner function.
+        pass
+
+
+# Re-implementing test_get_accounts_balances with delegation verification via patching ThreadPoolExecutor
+# effectively mocking concurrency.
+
+
+def test_get_accounts_balances_concurrency(wallet, mock_keys_and_services):
+    """Test get_accounts_balances concurrency."""
+    mock_keys_and_services["account_service"].return_value.get_account_data.return_value = {
+        "0x1": {"tag": "one"}
+    }
+
+    with patch("iwa.core.wallet.ThreadPoolExecutor") as mock_executor:
+        mock_context = MagicMock()
+        mock_executor.return_value.__enter__.return_value = mock_context
+
+        mock_future_native = MagicMock()
+        mock_future_native.result.return_value = ("0x1", "native", 1.5)
+
+        mock_future_token = MagicMock()
+        mock_future_token.result.return_value = ("0x1", "OLAS", 10.0)
+
+        # The loop order in wallet.py: for addr in accounts: for t in tokens: submit
+        # so for 1 account and 2 tokens: native, OLAS
+        mock_context.submit.side_effect = [mock_future_native, mock_future_token]
+
+        accounts, balances = wallet.get_accounts_balances("gnosis", ["native", "OLAS"])
+
+        assert accounts == {"0x1": {"tag": "one"}}
+        # balances structure: {addr: {token: val}}
+        assert balances["0x1"]["native"] == 1.5
+        assert balances["0x1"]["OLAS"] == 10.0
+
+
+def test_send_native_transfer(wallet, mock_keys_and_services):
+    """Test send_native_transfer."""
+    mock_keys_and_services["transfer_service"].return_value.send.return_value = "0xhash"
+    success, tx_hash = wallet.send_native_transfer("0xfrom", "0xto", 100, "gnosis")
+    assert success is True
+    assert tx_hash == "0xhash"
+    mock_keys_and_services["transfer_service"].return_value.send.assert_called_with(
+        from_address_or_tag="0xfrom",
+        to_address_or_tag="0xto",
+        amount_wei=100,
+        token_address_or_name="native",
+        chain_name="gnosis",
+    )
+
+
+def test_sign_and_send_transaction(wallet, mock_keys_and_services):
+    """Test sign_and_send_transaction."""
+    wallet.sign_and_send_transaction({"to": "0x1"}, "owner", "gnosis")
+    mock_keys_and_services["transaction_service"].return_value.sign_and_send.assert_called_with(
+        {"to": "0x1"}, "owner", "gnosis", None
+    )
+
+
+def test_send_erc20_transfer(wallet, mock_keys_and_services):
+    """Test send_erc20_transfer."""
+    mock_keys_and_services["transfer_service"].return_value.send.return_value = "0xhash"
+    success, tx_hash = wallet.send_erc20_transfer("0xfrom", "0xto", 100, "0xtoken", "gnosis")
+    assert success is True
+    assert tx_hash == "0xhash"
+    mock_keys_and_services["transfer_service"].return_value.send.assert_called_with(
+        from_address_or_tag="0xfrom",
+        to_address_or_tag="0xto",
+        amount_wei=100,
+        token_address_or_name="0xtoken",
+        chain_name="gnosis",
+    )
+
+
+def test_send(wallet, mock_keys_and_services):
+    """Test send."""
+    wallet.send("0xfrom", "0xto", 100)
+    mock_keys_and_services["transfer_service"].return_value.send.assert_called_with(
+        "0xfrom", "0xto", 100, "native", "gnosis"
+    )
+
+
+def test_multi_send(wallet, mock_keys_and_services):
+    """Test multi_send."""
+    txs = [{"to": "0x1", "value": 1}]
+    wallet.multi_send("0xfrom", txs, "gnosis")
+    mock_keys_and_services["transfer_service"].return_value.multi_send.assert_called_with(
+        "0xfrom", txs, "gnosis"
+    )
+
+
+def test_balances_getters(wallet, mock_keys_and_services):
+    """Test balances getters."""
+    mock_bs = mock_keys_and_services["balance_service"].return_value
+
+    wallet.get_native_balance_eth("0x1", "gnosis")
+    mock_bs.get_native_balance_eth.assert_called_with("0x1", "gnosis")
+
+    wallet.get_native_balance_wei("0x1", "gnosis")
+    mock_bs.get_native_balance_wei.assert_called_with("0x1", "gnosis")
+
+    wallet.get_erc20_balance_eth("0x1", "OLAS", "gnosis")
+    mock_bs.get_erc20_balance_eth.assert_called_with("0x1", "OLAS", "gnosis")
+
+    wallet.get_erc20_balance_wei("0x1", "OLAS", "gnosis")
+    mock_bs.get_erc20_balance_wei.assert_called_with("0x1", "OLAS", "gnosis")
+
+
+def test_erc20_operations(wallet, mock_keys_and_services):
+    """Test erc20 operations."""
+    mock_trs = mock_keys_and_services["transfer_service"].return_value
+
+    wallet.get_erc20_allowance("owner", "spender", "token", "gnosis")
+    mock_trs.get_erc20_allowance.assert_called_with("owner", "spender", "token", "gnosis")
+
+    wallet.approve_erc20("owner", "spender", "token", 100, "gnosis")
+    mock_trs.approve_erc20.assert_called_with("owner", "spender", "token", 100, "gnosis")
+
+    wallet.transfer_from_erc20("from", "sender", "recipient", "token", 100, "gnosis")
+    mock_trs.transfer_from_erc20.assert_called_with(
+        "from", "sender", "recipient", "token", 100, "gnosis"
+    )
+
+
+@pytest.mark.asyncio
+async def test_swap(wallet, mock_keys_and_services):
+    """Test swap."""
+    mock_trs = mock_keys_and_services["transfer_service"].return_value
+
+    # Mock swap as async method
+    mock_trs.swap = AsyncMock(return_value=True)
+
+    result = await wallet.swap("account", 1.0, "SELL", "BUY", "gnosis")
+    assert result is True
+
+    # Check if await matches call args
+    # Note: Enum handling might need import, passing string/value might be tested
+    args, kwargs = mock_trs.swap.call_args
+    assert args[0] == "account"
+    assert args[1] == 1.0
+
+
+def test_drain(wallet, mock_keys_and_services):
+    """Test drain."""
+    wallet.drain("from", "to", "gnosis")
+    mock_keys_and_services["transfer_service"].return_value.drain.assert_called_with(
+        "from", "to", "gnosis"
+    )

iwa/core/types.py

@@ -0,0 +1,59 @@
+"""Core type definitions."""
+
+import re
+
+import yaml
+from pydantic_core import core_schema
+from web3 import Web3
+
+ETHEREUM_ADDRESS_REGEX = r"0x[0-9a-fA-F]{40}"
+
+
+class EthereumAddress(str):
+    """EthereumAddress - a checksummed Ethereum address that behaves as a plain str.
+
+    When passed to web3.py functions, this behaves exactly like a str.
+    The class validates and checksums addresses on creation.
+    """
+
+    def __new__(cls, value: str):
+        """Create a new EthereumAddress instance."""
+        if not re.fullmatch(ETHEREUM_ADDRESS_REGEX, value):
+            raise ValueError(f"Invalid Ethereum address: {value}")
+        checksummed = Web3.to_checksum_address(value)
+        instance = str.__new__(cls, checksummed)
+        return instance
+
+    def __repr__(self) -> str:
+        """Return string representation for debugging."""
+        return str.__str__(self)
+
+    def __str__(self) -> str:
+        """Return as plain string - critical for web3.py compatibility."""
+        return str.__str__(self)
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source, _handler):
+        """Get the Pydantic core schema for EthereumAddress."""
+        return core_schema.with_info_after_validator_function(
+            cls.validate,
+            core_schema.str_schema(),
+        )
+
+    @classmethod
+    def validate(cls, value: str, _info) -> "EthereumAddress":
+        """Validate that the value is a valid Ethereum address."""
+        if not re.fullmatch(ETHEREUM_ADDRESS_REGEX, value):
+            raise ValueError(f"Invalid Ethereum address: {value}")
+        return cls(value)
+
+
+# Register YAML representer so EthereumAddress serializes as plain string
+def _ethereum_address_representer(
+    dumper: yaml.SafeDumper, data: EthereumAddress
+) -> yaml.ScalarNode:
+    """Represent EthereumAddress as a plain YAML string."""
+    return dumper.represent_str(str.__str__(data))
+
+
+yaml.add_representer(EthereumAddress, _ethereum_address_representer, Dumper=yaml.SafeDumper)

iwa/core/ui.py

@@ -0,0 +1,99 @@
+"""UI utilities for mnemonic handling."""
+
+import getpass
+import os
+
+from rich import box
+from rich.align import Align
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from iwa.core.mnemonic import MnemonicManager
+
+
+def prompt_and_store_mnemonic(
+    manager: MnemonicManager, out_file: str = None, max_attempts: int = 3
+) -> None:
+    """Prompt for a password twice, verify they match, and store mnemonic.
+
+    Args:
+        manager (MnemonicManager): The manager instance.
+        out_file (str): Optional destination file for the encrypted object.
+        max_attempts (int): Number of attempts allowed for confirmation.
+
+    Returns:
+        str | None: The plaintext mnemonic if successful, otherwise None.
+
+    """
+    target_file = out_file or manager.mnemonic_file
+    if os.path.exists(target_file):
+        print(f"Mnemonic file '{target_file}' already exists.")
+        return None
+
+    for _ in range(max_attempts):
+        p1 = getpass.getpass("Enter a strong password to encrypt the mnemonic: ").strip()
+        if not p1:
+            print("Empty password not allowed.")
+            continue
+        p2 = getpass.getpass("Confirm password: ").strip()
+        if p1 != p2:
+            print("Passwords do not match. Please try again.")
+            continue
+        # Passwords match — generate and store mnemonic
+        manager.generate_and_store_mnemonic(p1, target_file)
+        return None
+    raise ValueError("Maximum password attempts exceeded.")
+
+
+def display_mnemonic(
+    mnemonic: str,
+    columns: int = 6,
+    rows: int = 4,
+) -> None:
+    """Format and print a mnemonic as a numbered table wrapped in a Panel.
+
+    Args:
+        mnemonic (str): The plaintext mnemonic (space separated words).
+        columns (int): Number of columns per row (default 6).
+        rows (int): Number of rows (default 4).
+
+    """
+    words = mnemonic.split()
+    console = Console()
+    # build table without internal borders; we'll wrap it in a Panel
+    table = Table(
+        show_header=False,
+        box=None,
+        show_lines=False,
+        expand=False,
+    )
+    # add columns
+    for _ in range(columns):
+        table.add_column(justify="left")
+    # warning: advise user to create a paper backup
+    console.print(
+        "[bold yellow]Warning:[/bold yellow] Make a paper backup of "
+        "your mnemonic and store it in a safe place:"
+    )
+    # prepare numbered cells (colored green) with padded indices
+    cells = []
+    for i, w in enumerate(words):
+        cells.append(f"[green]{i + 1:2d}. {w}[/green]")
+    # add rows of `columns` columns
+    for r in range(rows):
+        start = r * columns
+        row = cells[start : start + columns]
+        # if row shorter than columns, pad with empty strings
+        if len(row) < columns:
+            row += [""] * (columns - len(row))
+        table.add_row(*row)
+    # wrap table in a panel to draw only the outer border
+    panel = Panel(
+        table,
+        box=box.ROUNDED,
+        border_style="bright_blue",
+        padding=(0, 1),
+        expand=False,
+    )
+    console.print(Align.center(panel))

iwa/core/utils.py

@@ -0,0 +1,59 @@
+"""Utility functions"""
+
+from loguru import logger
+from safe_eth.eth import EthereumNetwork
+from safe_eth.safe.addresses import MASTER_COPIES, PROXY_FACTORIES
+
+
+def singleton(cls):
+    """Singleton decorator to ensure a class has only one instance."""
+    instances = {}
+
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance
+
+
+def get_safe_master_copy_address(target_version: str = "1.4.1") -> str:
+    """Get Safe master copy address by version"""
+    for address, _, version in MASTER_COPIES[EthereumNetwork.MAINNET]:
+        if version == target_version:
+            return address
+    raise ValueError(f"Did not find master copy for version {target_version}")
+
+
+def get_safe_proxy_factory_address(target_version: str = "1.4.1") -> str:
+    """Get Safe proxy factory address by version"""
+    # PROXY_FACTORIES values are (address, block_number) without version
+    # converting 1.4.1 address manually if needed, or returning the one found.
+    # The address 0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67 is for 1.4.1
+    if target_version == "1.4.1":
+        return "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67"
+
+    for address, _ in PROXY_FACTORIES[EthereumNetwork.MAINNET]:
+        return address
+    raise ValueError(f"Did not find proxy factory for version {target_version}")
+
+
+def configure_logger():
+    """Configure the logger for the application."""
+    if hasattr(configure_logger, "configured"):
+        return logger
+
+    logger.remove()
+
+    logger.add(
+        "iwa.log",
+        rotation="10 MB",
+        level="INFO",
+        format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+    )
+    # Also keep stderr for console if needed, but Textual captures it?
+    # Textual usually captures stderr. Writing to file is safer for debugging.
+    # Users previous logs show stdout format?
+
+    configure_logger.configured = True
+    return logger