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

tests/test_transfer_swap_unit.py

@@ -0,0 +1,155 @@
+"""Unit tests for SwapMixin.swap logic."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from iwa.core.services.transfer.swap import OrderType, SwapMixin
+
+
+# Dummy class to mixin
+class MockTransferService(SwapMixin):
+    def __init__(self):
+        self.balance_service = MagicMock()
+        self.account_service = MagicMock()
+        self.key_storage = MagicMock()
+        self.wallet = MagicMock()
+        self.get_erc20_allowance = MagicMock()
+        self.approve_erc20 = MagicMock()
+
+
+@pytest.fixture
+def transfer_service():
+    return MockTransferService()
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    with patch("iwa.core.services.transfer.swap.ChainInterfaces") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_cow_swap():
+    with patch("iwa.core.services.transfer.swap.CowSwap") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_erc20_contract():
+    with patch("iwa.core.services.transfer.swap.ERC20Contract") as mock:
+        yield mock
+
+
+@pytest.fixture
+def mock_log_transaction():
+    with patch("iwa.core.services.transfer.swap.log_transaction") as mock:
+        yield mock
+
+
+@pytest.mark.asyncio
+async def test_swap_happy_path(
+    transfer_service, mock_chain_interfaces, mock_cow_swap, mock_log_transaction
+):
+    """Test successful swap with sufficient allowance."""
+    # Setup
+    account_mock = MagicMock()
+    account_mock.address = "0xUser"
+    transfer_service.account_service.resolve_account.return_value = account_mock
+    transfer_service.key_storage.get_signer.return_value = "signer"
+    transfer_service.key_storage.get_signer.return_value = "signer"
+    transfer_service.get_erc20_allowance.return_value = 10**18 + 100  # Sufficient
+
+    # Mock balance for pre-swap check
+    transfer_service.balance_service.get_erc20_balance_wei.return_value = 2 * 10**18
+    transfer_service.balance_service.get_native_balance_wei.return_value = 2 * 10**18
+
+    # Mock CowSwap instance
+    cow_instance = AsyncMock()
+    mock_cow_swap.return_value = cow_instance
+
+    # Mock Swap Result
+    swap_result = {
+        "executedSellAmount": "1000000000000000000",
+        "executedBuyAmount": "2000000",
+        "quote": {"sellTokenPrice": 1.0, "buyTokenPrice": 500.0},
+        "txHash": "0xHash",
+    }
+    cow_instance.swap.return_value = swap_result
+
+    # Execute
+    result = await transfer_service.swap(
+        account_address_or_tag="user",
+        amount_eth=1.0,
+        sell_token_name="WETH",
+        buy_token_name="USDC",
+        chain_name="gnosis",
+    )
+
+    # Verify
+    assert result == swap_result
+    # Check allowance was checked
+    transfer_service.get_erc20_allowance.assert_called_once()
+    # Check approval was skipped
+    transfer_service.approve_erc20.assert_not_called()
+    # Check logs
+    mock_log_transaction.assert_called_once()
+    assert result["analytics"]["value_change_pct"] != "N/A"
+
+
+@pytest.mark.asyncio
+async def test_swap_insufficient_allowance(transfer_service, mock_chain_interfaces, mock_cow_swap):
+    """Test approval is called when allowance is insufficient."""
+    # Setup
+    account_mock = MagicMock()
+    account_mock.address = "0xUser"
+    transfer_service.account_service.resolve_account.return_value = account_mock
+    transfer_service.key_storage.get_signer.return_value = "signer"
+    transfer_service.key_storage.get_signer.return_value = "signer"
+    transfer_service.get_erc20_allowance.return_value = 0  # Insufficient
+
+    # Mock balance for pre-swap check
+    transfer_service.balance_service.get_erc20_balance_wei.return_value = 2 * 10**18
+
+    cow_instance = AsyncMock()
+    mock_cow_swap.return_value = cow_instance
+    cow_instance.swap.return_value = {"txHash": "0xHash"}
+
+    # Execute
+    await transfer_service.swap(
+        account_address_or_tag="user", amount_eth=1.0, sell_token_name="WETH", buy_token_name="USDC"
+    )
+
+    # Verify Approval
+    transfer_service.approve_erc20.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_swap_full_balance(transfer_service, mock_chain_interfaces, mock_cow_swap):
+    """Test swapping entire balance (amount_eth=None)."""
+    # Setup
+    account_mock = MagicMock()
+    account_mock.address = "0xUser"
+    transfer_service.account_service.resolve_account.return_value = account_mock
+    transfer_service.key_storage.get_signer.return_value = "signer"
+
+    # Mock balance
+    transfer_service.balance_service.get_erc20_balance_wei.return_value = 500
+    transfer_service.get_erc20_allowance.return_value = 1000
+
+    cow_instance = AsyncMock()
+    mock_cow_swap.return_value = cow_instance
+    cow_instance.swap.return_value = {"txHash": "0xHash"}
+
+    # Execute
+    await transfer_service.swap(
+        account_address_or_tag="user",
+        amount_eth=None,
+        sell_token_name="WETH",
+        buy_token_name="USDC",
+    )
+
+    # Verify correct amount passed to swap
+    cow_instance.swap.assert_called_with(
+        amount_wei=500, sell_token_name="WETH", buy_token_name="USDC", order_type=OrderType.SELL
+    )

tests/test_ui_coverage.py

@@ -0,0 +1,66 @@
+"""Unit tests for UI utilities to improve coverage."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.ui import display_mnemonic, prompt_and_store_mnemonic
+
+
+def test_display_mnemonic():
+    """Test display_mnemonic."""
+    mnemonic = "one two three four five six seven eight nine ten eleven twelve"
+    with patch("iwa.core.ui.Console") as mock_console:
+        display_mnemonic(mnemonic)
+        assert mock_console.called
+
+
+def test_prompt_and_store_mnemonic_exists(tmp_path):
+    """Test when file exists."""
+    manager = MagicMock()
+    out_file = str(tmp_path / "exists.json")
+    with open(out_file, "w") as f:
+        f.write("{}")
+
+    assert prompt_and_store_mnemonic(manager, out_file=out_file) is None
+    assert manager.generate_and_store_mnemonic.called is False
+
+
+def test_prompt_and_store_mnemonic_success(tmp_path):
+    """Test successful mnemonic storage."""
+    manager = MagicMock()
+    out_file = str(tmp_path / "new.json")
+
+    with patch("getpass.getpass", side_effect=["pass", "pass"]):
+        assert prompt_and_store_mnemonic(manager, out_file=out_file) is None
+        manager.generate_and_store_mnemonic.assert_called_once_with("pass", out_file)
+
+
+def test_prompt_and_store_mnemonic_mismatch(tmp_path):
+    """Test password mismatch then success."""
+    manager = MagicMock()
+    out_file = str(tmp_path / "mismatch.json")
+
+    with patch("getpass.getpass", side_effect=["p1", "p2", "pass", "pass"]):
+        assert prompt_and_store_mnemonic(manager, out_file=out_file) is None
+        manager.generate_and_store_mnemonic.assert_called_once_with("pass", out_file)
+
+
+def test_prompt_and_store_mnemonic_empty(tmp_path):
+    """Test empty password then success."""
+    manager = MagicMock()
+    out_file = str(tmp_path / "empty.json")
+
+    with patch("getpass.getpass", side_effect=["", "pass", "pass"]):
+        assert prompt_and_store_mnemonic(manager, out_file=out_file) is None
+        manager.generate_and_store_mnemonic.assert_called_once_with("pass", out_file)
+
+
+def test_prompt_and_store_mnemonic_exhausted(tmp_path):
+    """Test exhaustion of attempts."""
+    manager = MagicMock()
+    out_file = str(tmp_path / "fail.json")
+
+    with patch("getpass.getpass", side_effect=["p1", "p2", "p3", "p4", "p5", "p6"]):
+        with pytest.raises(ValueError, match="Maximum password attempts exceeded"):
+            prompt_and_store_mnemonic(manager, out_file=out_file)

tests/test_utils.py

@@ -0,0 +1,53 @@
+from unittest.mock import patch
+
+import pytest
+
+from iwa.core.utils import get_safe_master_copy_address, singleton
+
+
+def test_get_safe_master_copy_address_found():
+    mock_master_copies = {
+        "mainnet": [
+            ("0xAddress1", "L2", "1.3.0"),
+            ("0xAddress2", "L2", "1.4.1"),
+        ]
+    }
+
+    with (
+        patch("iwa.core.utils.MASTER_COPIES", mock_master_copies),
+        patch("iwa.core.utils.EthereumNetwork") as mock_network,
+    ):
+        mock_network.MAINNET = "mainnet"
+
+        address = get_safe_master_copy_address("1.4.1")
+        assert address == "0xAddress2"
+
+
+def test_get_safe_master_copy_address_not_found():
+    mock_master_copies = {
+        "mainnet": [
+            ("0xAddress1", "L2", "1.3.0"),
+        ]
+    }
+
+    with (
+        patch("iwa.core.utils.MASTER_COPIES", mock_master_copies),
+        patch("iwa.core.utils.EthereumNetwork") as mock_network,
+    ):
+        mock_network.MAINNET = "mainnet"
+
+        with pytest.raises(ValueError, match="Did not find master copy"):
+            get_safe_master_copy_address("1.0.0")
+
+
+def test_singleton():
+    @singleton
+    class MyClass:
+        def __init__(self, val):
+            self.val = val
+
+    obj1 = MyClass(1)
+    obj2 = MyClass(2)
+
+    assert obj1 is obj2
+    assert obj1.val == 1

tests/test_workers.py

@@ -0,0 +1,91 @@
+"""Tests for MonitorWorker."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from iwa.tui.workers import MonitorWorker
+
+
+@pytest.mark.asyncio
+async def test_monitor_worker_init():
+    """Test initialization."""
+    mock_monitor = MagicMock()
+    mock_app = MagicMock()
+    worker = MonitorWorker(mock_monitor, mock_app)
+
+    assert worker.monitor == mock_monitor
+    assert worker.app == mock_app
+    assert not worker._running
+
+
+@pytest.mark.asyncio
+async def test_monitor_worker_stop():
+    """Test stop method."""
+    mock_monitor = MagicMock()
+    mock_app = MagicMock()
+    worker = MonitorWorker(mock_monitor, mock_app)
+    worker._running = True
+
+    worker.stop()
+
+    assert not worker._running
+    mock_monitor.stop.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_monitor_worker_run():
+    """Test run loop."""
+    mock_monitor = MagicMock()
+    mock_monitor.chain_name = "test_chain"
+    mock_app = MagicMock()
+    worker = MonitorWorker(mock_monitor, mock_app)
+
+    # Side effect to stop the loop after first iteration
+    def stop_worker(*args, **kwargs):
+        worker._running = False
+
+    mock_monitor.check_activity.side_effect = stop_worker
+
+    # We need to patch asyncio.sleep to avoid waiting
+    with patch("asyncio.sleep", new_callable=AsyncMock):
+        await worker.run()
+
+    assert mock_monitor.running
+    # check_activity is called in a thread, so we verify it was called
+    # Since it's run in to_thread, the side_effect happens in the thread
+    # But since we mock check_activity, side_effect executes.
+    # Wait, check_activity is called via asyncio.to_thread(self.monitor.check_activity)
+    # So we should verify check_activity was called.
+
+    mock_monitor.check_activity.assert_called()
+
+
+@pytest.mark.asyncio
+async def test_monitor_worker_run_error():
+    """Test run loop handles errors."""
+    mock_monitor = MagicMock()
+    mock_monitor.chain_name = "test_chain"
+    mock_app = MagicMock()
+    worker = MonitorWorker(mock_monitor, mock_app)
+
+    # Side effect: First call raises error, second call stops worker
+    async def side_effect(*args, **kwargs):
+        if not hasattr(side_effect, "called"):
+            side_effect.called = True
+            raise ValueError("Test Error")
+        worker._running = False
+        return None
+
+    worker._running = True
+
+    # Patch asyncio.to_thread to use our side effect
+    # We also patch sleep to be fast
+    with patch("asyncio.to_thread", side_effect=side_effect) as mock_to_thread:
+        with patch("asyncio.sleep", new_callable=AsyncMock):
+            await worker.run()
+
+    # This verifies passing through error handling
+    assert not worker._running
+    # Should be called twice (once error, once success/stop)
+    assert mock_to_thread.call_count >= 2

tools/verify_drain.py

@@ -0,0 +1,183 @@
+"""Verification script for draining services."""
+
+import logging
+import subprocess  # nosec: B404
+import sys
+import time
+from typing import List
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def run_command(command: List[str]):  # noqa: D103
+    logger.info(f"Running: {' '.join(command)}")
+    subprocess.run(command, check=True)  # nosec: B603
+
+
+def verify_drain():  # noqa: C901, D103
+    try:
+        # 1. Reset everything
+        logger.info("=== STEP 1: RESET ALL (This may take a moment) ===")
+        run_command(["just", "reset-all"])
+
+        logger.info("Waiting for reset to settle...")
+        time.sleep(5)
+
+        from iwa.core.wallet import Wallet
+        from iwa.plugins.olas.service_manager import ServiceManager
+
+        logger.info("Initializing Wallet & Manager...")
+        wallet = Wallet()
+        manager = ServiceManager(wallet)
+
+        # 2. Create Service
+        logger.info("=== STEP 2: CREATE & DEPLOY SERVICE ===")
+        logger.info("Creating service (default Trader)...")
+
+        # Bond 1 ETH
+        service_id = manager.create(chain_name="gnosis", bond_amount_wei=1000000000000000000)
+
+        if not service_id:
+            raise ValueError("Failed to create service")
+
+        logger.info(f"Service Created! ID: {service_id}")
+
+        logger.info(f"Spinning up service {service_id}...")
+        success = manager.spin_up(service_id=service_id)
+        if not success:
+            raise ValueError("Failed to spin up service")
+
+        # Refresh service details
+        if manager.service and manager.service.service_id == service_id:
+            service = manager.service
+        else:
+            assert manager.olas_config is not None, "Olas config not initialized"
+            service = manager.olas_config.get_service("gnosis", service_id)
+            if not service:
+                raise ValueError(f"Service {service_id} not found in config")
+
+        safe_addr = service.multisig_address
+        agent_addr = service.agent_address
+
+        logger.info(f"Safe Address: {safe_addr}")
+        logger.info(f"Agent Address: {agent_addr}")
+
+        if not safe_addr or not agent_addr:
+            # Fallback fetch if local object lagging
+            info = manager.registry.get_service(service_id)
+            logger.info(f"Registry Info: {info}")
+            assert manager.olas_config is not None, "Olas config not initialized"
+            service = manager.olas_config.get_service("gnosis", service_id)
+            if not service:
+                 raise ValueError(f"Service {service_id} not found in config")
+            safe_addr = service.multisig_address
+            agent_addr = service.agent_address
+
+        if not safe_addr or not agent_addr:
+            raise ValueError(
+                f"Failed to get Safe or Agent address. Safe={safe_addr}, Agent={agent_addr}"
+            )
+
+        # 3. Fund Accounts
+        logger.info("=== STEP 3: FUND ACCOUNT (Master -> Agent/Safe) ===")
+        amount_native_val = 1.0  # xDAI
+        amount_olas_val = 10.0  # OLAS
+
+        amount_native_wei = int(amount_native_val * 10**18)
+        amount_olas_wei = int(amount_olas_val * 10**18)
+
+        # Fund Agent
+        logger.info(f"Funding Agent {agent_addr}...")
+        wallet.transfer_service.send("master", agent_addr, amount_native_wei, "native", "gnosis")
+        wallet.transfer_service.send("master", agent_addr, amount_olas_wei, "OLAS", "gnosis")
+
+        # Fund Safe
+        logger.info(f"Funding Safe {safe_addr}...")
+        wallet.transfer_service.send("master", safe_addr, amount_native_wei, "native", "gnosis")
+        wallet.transfer_service.send("master", safe_addr, amount_olas_wei, "OLAS", "gnosis")
+
+        logger.info("Waiting 7s for indexing...")
+        time.sleep(7)
+
+        # Verify Funding
+        logger.info("Verifying balances...")
+        agent_native = wallet.balance_service.get_native_balance_eth(agent_addr, "gnosis") or 0.0
+        agent_olas = (
+            wallet.balance_service.get_erc20_balance_eth(agent_addr, "OLAS", "gnosis") or 0.0
+        )
+
+        safe_native = wallet.balance_service.get_native_balance_eth(safe_addr, "gnosis") or 0.0
+        safe_olas = wallet.balance_service.get_erc20_balance_eth(safe_addr, "OLAS", "gnosis") or 0.0
+
+        logger.info(f"Agent Balance: Native={agent_native}, OLAS={agent_olas}")
+        logger.info(f"Safe Balance: Native={safe_native}, OLAS={safe_olas}")
+
+        if agent_native < 0.9:
+            raise ValueError(f"Agent funding failed: {agent_native}")
+        if safe_native < 0.9:
+            raise ValueError(f"Safe funding failed: {safe_native}")
+
+        # 4. Drain Service
+        logger.info("=== STEP 4: DRAIN SERVICE ===")
+        manager_drain = ServiceManager(wallet, service_key=f"gnosis:{service_id}")
+
+        logger.info("Executing drain_service()...")
+        drained = manager_drain.drain_service()
+        logger.info(f"Drain result: {drained}")
+
+        logger.info("Waiting 7s for indexing after drain...")
+        time.sleep(7)
+
+        # 5. Verify Zero Balance
+        logger.info("=== STEP 5: VERIFY 0 BALANCE ===")
+
+        final_agent_native = (
+            wallet.balance_service.get_native_balance_eth(agent_addr, "gnosis") or 0.0
+        )
+        final_agent_olas = (
+            wallet.balance_service.get_erc20_balance_eth(agent_addr, "OLAS", "gnosis") or 0.0
+        )
+
+        final_safe_native = (
+            wallet.balance_service.get_native_balance_eth(safe_addr, "gnosis") or 0.0
+        )
+        final_safe_olas = (
+            wallet.balance_service.get_erc20_balance_eth(safe_addr, "OLAS", "gnosis") or 0.0
+        )
+
+        logger.info(f"Final Agent Balance: Native={final_agent_native}, OLAS={final_agent_olas}")
+        logger.info(f"Final Safe Balance: Native={final_safe_native}, OLAS={final_safe_olas}")
+
+        errors = []
+
+        # Checks
+        if final_agent_native > 0.02:
+            errors.append(f"Agent still has native: {final_agent_native}")
+
+        if final_agent_olas > 0.000001:
+            errors.append(f"Agent still has OLAS: {final_agent_olas}")
+
+        if final_safe_native > 0.005:
+            # Safe drain is precise when using safe txn
+            errors.append(f"Safe still has native: {final_safe_native}")
+
+        if final_safe_olas > 0.000001:
+            errors.append(f"Safe still has OLAS: {final_safe_olas}")
+
+        if errors:
+            logger.error("❌ VERIFICATION FAILED:")
+            for e in errors:
+                logger.error(f"  - {e}")
+            sys.exit(1)
+
+        logger.info("✅ SUCCESS: Service drained completely!")
+
+    except Exception as e:
+        logger.exception(f"Verification process failed with exception: {e}")
+        # sys.exit(1) # actually let log trace propagate
+
+
+if __name__ == "__main__":
+    verify_drain()

__init__.py

@@ -1,2 +0,0 @@
-def hello(name: str = "world") -> str:
-    return f"Hello, {name}!"

hello.py

@@ -1,6 +0,0 @@
-def main():
-    print("Hello!")
-
-
-if __name__ == "__main__":
-    main()

iwa-0.0.0.dist-info/METADATA

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: iwa
-Version: 0.0.0
-Summary: Add your description here
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# Iwa
-
-A packaging example

iwa-0.0.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-__init__.py,sha256=sBF3fhvD4D-ITi6Q6esr1QEoq433RKO9cJSNm6yy7ac,67
-hello.py,sha256=5eAormQmiU9ZodzSDPvTuQKokBhVFnRE6m-KrStftN8,72
-iwa-0.0.0.dist-info/METADATA,sha256=-Z_hiTEX_-4NBXCqV1JxQuaJ_oy9SjSkWRpMGh7JxJo,174
-iwa-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iwa-0.0.0.dist-info/top_level.txt,sha256=2Qir6NE0bKuCfTi-7V_-BoA1-QYuU7aoBiQsuWXUXpw,15
-iwa-0.0.0.dist-info/RECORD,,

iwa-0.0.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-__init__
-hello