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

tests/test_safe_service.py

@@ -0,0 +1,168 @@
+"""Tests for core SafeService."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.keys import EncryptedAccount, KeyStorage
+from iwa.core.services.safe import SafeService
+
+
+@pytest.fixture
+def mock_key_storage():
+    """Mock key storage."""
+    mock = MagicMock(spec=KeyStorage)
+    mock.accounts = {}
+
+    # Mock find_stored_account to return appropriate account types
+    def find_account(tag_or_addr):
+        if tag_or_addr == "deployer":
+            acc = MagicMock(spec=EncryptedAccount)
+            # Valid checksum address - Deployer
+            acc.address = "0xAB7C8803962c0f2F5BBBe3FA8BF0Dcd705084223"
+            return acc
+        if tag_or_addr == "owner1":
+            acc = MagicMock(spec=EncryptedAccount)
+            # Valid checksum address - Owner
+            acc.address = "0x5A0b54D5dc17e0AadC383d2db43B0a0D3E029c4c"
+            return acc
+        return None
+
+    mock.find_stored_account.side_effect = find_account
+
+    # Mock private key retrieval
+    mock._get_private_key.return_value = (
+        "0x1234567890123456789012345678901234567890123456789012345678901234"
+    )
+
+    return mock
+
+
+@pytest.fixture
+def mock_account_service():
+    """Mock account service."""
+    mock = MagicMock()
+    mock.get_tag_by_address.return_value = "deployer_tag"
+    return mock
+
+
+@pytest.fixture
+def mock_dependencies():
+    """Mock external dependencies (Safe, EthereumClient, etc)."""
+    with (
+        patch("iwa.core.services.safe.EthereumClient") as mock_client,
+        patch("iwa.core.services.safe.Safe") as mock_safe,
+        patch("iwa.core.services.safe.ProxyFactory") as mock_proxy_factory,
+        patch("iwa.core.services.safe.settings") as mock_settings,
+        patch("iwa.core.services.safe.log_transaction") as mock_log,
+        patch("iwa.core.services.safe.get_safe_master_copy_address") as mock_master,
+        patch("iwa.core.services.safe.get_safe_proxy_factory_address") as mock_factory,
+    ):
+        mock_settings.gnosis_rpc.get_secret_value.return_value = "http://rpc"
+
+        # Setup Safe creation return
+        mock_create_tx = MagicMock()
+        # Valid Checksum Address - New Safe (Matches Pydantic output)
+        mock_create_tx.contract_address = "0xbEC49fa140ACaa83533f900357DCD37866d50618"
+        mock_create_tx.tx_hash.hex.return_value = "0xTxHash"
+
+        mock_safe.create.return_value = mock_create_tx
+
+        # Setup ProxyFactory return
+        mock_deploy_tx = MagicMock()
+        # Valid checksum address - Salted Safe
+        mock_deploy_tx.contract_address = "0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5"
+        mock_deploy_tx.tx_hash.hex.return_value = "0xTxHashSalted"
+
+        mock_proxy_factory.return_value.deploy_proxy_contract_with_nonce.return_value = (
+            mock_deploy_tx
+        )
+
+        # Fix for setup_data chaining
+        mock_function = MagicMock()
+        mock_function.build_transaction.return_value = {"data": "0x1234"}
+
+        mock_contract = MagicMock()
+        mock_contract.functions.setup.return_value = mock_function
+
+        mock_safe_instance = MagicMock()
+        mock_safe_instance.contract = mock_contract
+
+        def safe_side_effect(*args, **kwargs):
+            return mock_safe_instance
+
+        mock_safe.side_effect = safe_side_effect
+        mock_safe.create.return_value = mock_create_tx
+
+        # Mock get_transaction_receipt for gas calc
+        mock_client.return_value.w3.eth.get_transaction_receipt.return_value = {
+            "gasUsed": 50000,
+            "effectiveGasPrice": 20,
+        }
+
+        yield {
+            "client": mock_client,
+            "safe": mock_safe,
+            "proxy_factory": mock_proxy_factory,
+            "settings": mock_settings,
+            "log": mock_log,
+            "master": mock_master,
+            "factory": mock_factory,
+        }
+
+
+def test_create_safe_standard(mock_key_storage, mock_account_service, mock_dependencies):
+    """Test standard create_safe without salt."""
+    service = SafeService(mock_key_storage, mock_account_service)
+
+    safe_account, tx_hash = service.create_safe(
+        deployer_tag_or_address="deployer",
+        owner_tags_or_addresses=["owner1"],
+        threshold=1,
+        chain_name="gnosis",
+        tag="MySafe",
+    )
+
+    # Checksum address matching what Pydantic/Web3 produces
+    assert safe_account.address == "0xbEC49fa140ACaa83533f900357DCD37866d50618"
+    assert safe_account.tag == "MySafe"
+    assert tx_hash == "0xTxHash"
+
+    mock_dependencies["safe"].create.assert_called_once()
+    mock_key_storage.save.assert_called_once()
+
+
+def test_create_safe_with_salt(mock_key_storage, mock_account_service, mock_dependencies):
+    """Test create_safe with salt nonce."""
+    service = SafeService(mock_key_storage, mock_account_service)
+
+    mock_dependencies["client"].return_value.w3.eth.gas_price = 1000
+
+    safe_account, tx_hash = service.create_safe(
+        deployer_tag_or_address="deployer",
+        owner_tags_or_addresses=["owner1"],
+        threshold=1,
+        chain_name="gnosis",
+        tag="MySaltedSafe",
+        salt_nonce=123,
+    )
+
+    # 0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5
+    assert safe_account.address == "0xDAFEA492D9c6733ae3d56b7Ed1ADB60692c98Bc5"
+    assert tx_hash == "0xTxHashSalted"
+
+    # Check that manual ProxyFactory logic was used
+    mock_dependencies[
+        "proxy_factory"
+    ].return_value.deploy_proxy_contract_with_nonce.assert_called_once()
+    # Safe.create should NOT be called
+    mock_dependencies["safe"].create.assert_not_called()
+
+
+def test_create_safe_invalid_deployer(mock_key_storage, mock_account_service):
+    """Test error when deployer invalid."""
+    mock_key_storage.find_stored_account.return_value = None
+    service = SafeService(mock_key_storage, mock_account_service)
+
+    with pytest.raises(ValueError, match="Deployer account .* not found"):
+        service.create_safe("invalid", [], 1, "gnosis")

tests/test_service_manager_integration.py

@@ -0,0 +1,61 @@
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_main():
+    # Create mocks for all required modules
+    mock_cowpy = MagicMock()
+    modules_to_patch = {
+        "cowdao_cowpy": mock_cowpy,
+        "cowdao_cowpy.common": MagicMock(),
+        "cowdao_cowpy.common.chains": MagicMock(),
+        "cowdao_cowpy.app_data": MagicMock(),
+        "cowdao_cowpy.app_data.utils": MagicMock(),
+        "cowdao_cowpy.contracts": MagicMock(),
+        "cowdao_cowpy.contracts.order": MagicMock(),
+        "cowdao_cowpy.contracts.sign": MagicMock(),
+        "cowdao_cowpy.cow": MagicMock(),
+        "cowdao_cowpy.cow.swap": MagicMock(),
+        "cowdao_cowpy.order_book": MagicMock(),
+        "cowdao_cowpy.order_book.api": MagicMock(),
+        "cowdao_cowpy.order_book.config": MagicMock(),
+        "cowdao_cowpy.order_book.generated": MagicMock(),
+        "cowdao_cowpy.order_book.generated.model": MagicMock(),
+    }
+
+    with patch.dict(sys.modules, modules_to_patch):
+        # Ensure iwa.core.wallet is imported so we can patch it
+        # We need to make sure it's re-imported if it was already imported,
+        # to use the mocked cowdao_cowpy if needed, but actually we just need to patch Wallet.
+        # If iwa.core.wallet is already imported, patching Wallet is enough.
+        # But iwa.core.test might be already imported.
+        if "iwa.core.test" in sys.modules:
+            del sys.modules["iwa.core.test"]
+
+        # We need to ensure iwa.core.wallet is importable.
+        # If it's not in sys.modules, import it.
+        # But importing it triggers cowdao_cowpy import.
+        # Since we patched sys.modules, it should use our mocks.
+        if "iwa.core.wallet" not in sys.modules:
+            pass
+
+        with (
+            patch("iwa.core.wallet.Wallet"),
+            patch("iwa.core.test.ServiceManager") as mock_service_manager,
+        ):
+            # Import main here
+            from iwa.core.test import main
+
+            # Mock the instance returned by ServiceManager()
+            mock_sm_instance = mock_service_manager.return_value
+
+            await main()
+
+            # Verify ServiceManager was initialized with wallet
+            mock_service_manager.assert_called()
+
+            # Verify create was called
+            mock_sm_instance.create.assert_called_once()

tests/test_service_manager_structure.py

@@ -0,0 +1,31 @@
+from unittest.mock import MagicMock
+
+from iwa.plugins.olas.service_manager import ServiceManager
+
+
+def test_service_manager_structure():
+    """Verify that ServiceManager has all expected methods from mixins."""
+    wallet_mock = MagicMock()
+    sm = ServiceManager(wallet=wallet_mock)
+
+    # Check Lifecycle methods
+    assert hasattr(sm, "create")
+    assert hasattr(sm, "deploy")
+    assert hasattr(sm, "spin_up")
+    assert hasattr(sm, "wind_down")
+
+    # Check Staking methods
+    assert hasattr(sm, "stake")
+    assert hasattr(sm, "unstake")
+    assert hasattr(sm, "get_staking_status")
+
+    # Check Drain methods
+    assert hasattr(sm, "drain_service")
+    assert hasattr(sm, "claim_rewards")
+
+    # Check Mech methods
+    assert hasattr(sm, "send_mech_request")
+
+    # Check Base methods
+    assert hasattr(sm, "get")
+    assert hasattr(sm, "_init_contracts")

tests/test_service_transaction.py

@@ -0,0 +1,176 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.chain import Gnosis
+from iwa.core.services.transaction import TransactionService
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    with patch("iwa.core.services.transaction.ChainInterfaces") as mock:
+        instance = mock.return_value
+        gnosis_interface = MagicMock()
+        mock_chain = MagicMock(spec=Gnosis)
+        mock_chain.name = "Gnosis"
+        mock_chain.chain_id = 100
+        gnosis_interface.chain = mock_chain
+        gnosis_interface.web3 = MagicMock()
+        instance.get.return_value = gnosis_interface
+        yield instance
+
+
+@pytest.fixture
+def mock_key_storage():
+    return MagicMock()
+
+
+@pytest.fixture
+def mock_account_service():
+    return MagicMock()
+
+
+@pytest.fixture
+def transaction_service(mock_key_storage, mock_account_service):
+    return TransactionService(mock_key_storage, mock_account_service)
+
+
+def test_sign_and_send_success(
+    transaction_service, mock_key_storage, mock_chain_interfaces, mock_account_service
+):
+    # Setup
+    tx = {"to": "0x123", "value": 100, "nonce": 5, "chainId": 100}
+    mock_key_storage.sign_transaction.return_value = MagicMock(raw_transaction=b"raw_tx")
+
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.send_raw_transaction.return_value = b"tx_hash"
+    chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+
+    mock_account_service.resolve_account.return_value = MagicMock(address="0xSigner")
+
+    # Call
+    success, receipt = transaction_service.sign_and_send(tx, "signer")
+
+    # Assert
+    assert success is True
+    assert receipt.status == 1
+    mock_key_storage.sign_transaction.assert_called_with(tx, "signer")
+    chain_interface.web3.eth.send_raw_transaction.assert_called_with(b"raw_tx")
+    chain_interface.wait_for_no_pending_tx.assert_called_with("0xSigner")
+
+
+def test_sign_and_send_retry_on_low_gas(
+    transaction_service, mock_key_storage, mock_chain_interfaces
+):
+    # Setup
+    tx = {"to": "0x123", "value": 100, "nonce": 5, "gas": 10000}
+    mock_key_storage.sign_transaction.return_value = MagicMock(raw_transaction=b"raw_tx")
+
+    chain_interface = mock_chain_interfaces.get.return_value
+
+    # Simulate low gas error then success
+    from web3 import exceptions
+
+    chain_interface.web3.eth.send_raw_transaction.side_effect = [
+        exceptions.Web3RPCError("intrinsic gas too low"),
+        b"tx_hash",
+    ]
+    chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+
+    # Call
+    with patch("time.sleep"):
+        success, receipt = transaction_service.sign_and_send(tx, "signer")
+
+    # Assert
+    assert success is True
+    assert chain_interface.web3.eth.send_raw_transaction.call_count == 2
+    # Verify gas increase
+    # arguments passed to sign_transaction should reflect updated gas
+    args, _ = mock_key_storage.sign_transaction.call_args_list[1]
+    assert args[0]["gas"] == 15000  # 10000 * 1.5
+
+
+# --- Negative Tests ---
+
+
+def test_sign_and_send_max_retries_exhausted(
+    transaction_service, mock_key_storage, mock_chain_interfaces
+):
+    """Test sign_and_send fails after max gas retries."""
+    tx = {"to": "0x123", "value": 100, "nonce": 5, "gas": 10000}
+    mock_key_storage.sign_transaction.return_value = MagicMock(raw_transaction=b"raw_tx")
+
+    chain_interface = mock_chain_interfaces.get.return_value
+
+    # Always fail with low gas error
+    from web3 import exceptions
+
+    chain_interface.web3.eth.send_raw_transaction.side_effect = exceptions.Web3RPCError(
+        "intrinsic gas too low"
+    )
+
+    with patch("time.sleep"):
+        success, receipt = transaction_service.sign_and_send(tx, "signer")
+
+    # Should fail after max retries
+    assert success is False
+    assert receipt == {}  # Returns empty dict on failure
+    # Should have tried 3 times (max_retries)
+    assert chain_interface.web3.eth.send_raw_transaction.call_count == 3
+
+
+def test_sign_and_send_transaction_reverted(
+    transaction_service, mock_key_storage, mock_chain_interfaces
+):
+    """Test sign_and_send handles reverted transaction."""
+    tx = {"to": "0x123", "value": 100, "nonce": 5, "gas": 21000}
+    mock_key_storage.sign_transaction.return_value = MagicMock(raw_transaction=b"raw_tx")
+
+    chain_interface = mock_chain_interfaces.get.return_value
+    chain_interface.web3.eth.send_raw_transaction.return_value = b"tx_hash"
+    # Transaction mined but reverted (status=0)
+    chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=0)
+
+    success, receipt = transaction_service.sign_and_send(tx, "signer")
+
+    assert success is False
+    assert receipt == {}  # Returns empty dict on reverted tx
+
+
+def test_sign_and_send_rpc_error_triggers_rotation(
+    transaction_service, mock_key_storage, mock_chain_interfaces
+):
+    """Test sign_and_send rotates RPC on connection error."""
+    tx = {"to": "0x123", "value": 100, "nonce": 5, "gas": 21000}
+    mock_key_storage.sign_transaction.return_value = MagicMock(raw_transaction=b"raw_tx")
+
+    chain_interface = mock_chain_interfaces.get.return_value
+
+    # First call fails with connection error, second succeeds
+    chain_interface.web3.eth.send_raw_transaction.side_effect = [
+        ConnectionError("Connection refused"),
+        b"tx_hash",
+    ]
+    chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(status=1)
+    chain_interface.rotate_rpc.return_value = True
+
+    with patch("time.sleep"):
+        success, receipt = transaction_service.sign_and_send(tx, "signer")
+
+    assert success is True
+    chain_interface.rotate_rpc.assert_called()
+
+
+def test_sign_and_send_signer_not_found(
+    transaction_service, mock_key_storage, mock_chain_interfaces, mock_account_service
+):
+    """Test sign_and_send fails when signer account not found."""
+    tx = {"to": "0x123", "value": 100, "nonce": 5}
+
+    # Signing raises ValueError for unknown account
+    mock_key_storage.sign_transaction.side_effect = ValueError("Account not found")
+
+    success, receipt = transaction_service.sign_and_send(tx, "unknown_signer")
+
+    assert success is False
+    assert receipt == {}  # Returns empty dict on failure

tests/test_staking_router.py

@@ -0,0 +1,71 @@
+"""Tests for staking.py router coverage."""
+
+from unittest.mock import MagicMock
+
+
+def test_check_availability_exception():
+    """Test _check_availability handles contract call failures."""
+    from iwa.web.routers.olas.staking import _check_availability
+
+    mock_w3 = MagicMock()
+    mock_w3.eth.contract.side_effect = Exception("Contract error")
+
+    result = _check_availability("Test", "0xAddr", mock_w3, [])
+    assert result["name"] == "Test"
+    assert result["usage"] is None
+
+
+def test_filter_contracts_no_availability():
+    """Test _filter_contracts excludes unavailable contracts."""
+    from iwa.web.routers.olas.staking import _filter_contracts
+
+    results = [
+        {"name": "A", "usage": {"available": False}, "min_staking_deposit": 100},
+        {"name": "B", "usage": {"available": True}, "min_staking_deposit": 100},
+    ]
+    filtered = _filter_contracts(results, None, None)
+    assert len(filtered) == 1
+    assert filtered[0]["name"] == "B"
+
+
+def test_filter_contracts_bond_too_low():
+    """Test _filter_contracts excludes contracts where bond is too low."""
+    from iwa.web.routers.olas.staking import _filter_contracts
+
+    results = [
+        {"name": "A", "usage": {"available": True}, "min_staking_deposit": 1000},
+    ]
+    filtered = _filter_contracts(results, service_bond=500, service_token=None)
+    assert len(filtered) == 0
+
+
+def test_filter_contracts_token_mismatch():
+    """Test _filter_contracts excludes contracts with wrong token."""
+    from iwa.web.routers.olas.staking import _filter_contracts
+
+    results = [
+        {
+            "name": "A",
+            "usage": {"available": True},
+            "min_staking_deposit": 100,
+            "staking_token": "0xOtherToken",
+        },
+    ]
+    filtered = _filter_contracts(results, service_bond=500, service_token="0xmytoken")
+    assert len(filtered) == 0
+
+
+def test_filter_contracts_compatible():
+    """Test _filter_contracts includes compatible contracts."""
+    from iwa.web.routers.olas.staking import _filter_contracts
+
+    results = [
+        {
+            "name": "A",
+            "usage": {"available": True},
+            "min_staking_deposit": 100,
+            "staking_token": "0xMyToken",
+        },
+    ]
+    filtered = _filter_contracts(results, service_bond=500, service_token="0xmytoken")
+    assert len(filtered) == 1

tests/test_staking_simple.py

@@ -0,0 +1,31 @@
+from unittest.mock import MagicMock, mock_open, patch
+
+from iwa.plugins.olas.contracts.staking import StakingContract
+
+
+def test_staking_contract_coverage():
+    with (
+        patch("iwa.core.contracts.contract.ChainInterfaces") as mock_chains,
+        patch("iwa.plugins.olas.contracts.staking.ActivityCheckerContract"),
+        patch("builtins.open", mock_open(read_data="[]")),
+    ):
+        # Setup mocks
+        mock_interface = MagicMock()
+        mock_chains.return_value.get.return_value = mock_interface
+
+        # Mock contract calls in __init__
+        mock_interface.call_contract.side_effect = lambda method, *args: {
+            "activityChecker": "0xChecker",
+            "availableRewards": 100,
+            "balance": 1000,
+            "livenessPeriod": 3600,
+            "rewardsPerSecond": 1,
+            "maxNumServices": 10,
+            "minStakingDeposit": 100,
+            "minStakingDuration": 86400,
+            "stakingToken": "0xToken",
+        }.get(method, 0)
+
+        # Instantiate (This covers __init__ logic)
+        contract = StakingContract(address="0x123")
+        assert contract.address == "0x123"

tests/test_tables.py

@@ -0,0 +1,76 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.models import StoredAccount, StoredSafeAccount
+from iwa.core.tables import list_accounts
+
+
+@pytest.fixture
+def mock_console():
+    with patch("iwa.core.tables.Console") as mock:
+        yield mock.return_value
+
+
+@pytest.fixture
+def mock_chain_interface():
+    mock = MagicMock()
+    mock.chain.native_currency = "ETH"
+    return mock
+
+
+def test_list_accounts_empty(mock_console, mock_chain_interface):
+    list_accounts(None, mock_chain_interface, None, None)
+    mock_console.print.assert_called_once()
+    # Could verify table content but that's harder with mocks.
+    # Just ensuring it runs without error and prints something is good for coverage.
+
+
+def test_list_accounts_eoa(mock_console, mock_chain_interface):
+    accounts = {
+        "0x5B38Da6a701c568545dCfcB03FcB875f56beddC4": StoredAccount(
+            address="0x5B38Da6a701c568545dCfcB03FcB875f56beddC4", tag="tag1"
+        )
+    }
+    list_accounts(accounts, mock_chain_interface, None, None)
+    mock_console.print.assert_called_once()
+
+
+def test_list_accounts_safe(mock_console, mock_chain_interface):
+    accounts = {
+        "0x61a4f49e9dD1f90EB312889632FA956a21353720": StoredSafeAccount(
+            address="0x61a4f49e9dD1f90EB312889632FA956a21353720",
+            tag="tag2",
+            signers=["0x5B38Da6a701c568545dCfcB03FcB875f56beddC4"],
+            threshold=1,
+            chains=["gnosis"],
+        )
+    }
+    list_accounts(accounts, mock_chain_interface, None, None)
+    mock_console.print.assert_called_once()
+
+
+def test_list_accounts_with_tokens(mock_console, mock_chain_interface):
+    accounts = {
+        "0x5B38Da6a701c568545dCfcB03FcB875f56beddC4": StoredAccount(
+            address="0x5B38Da6a701c568545dCfcB03FcB875f56beddC4", tag="tag1"
+        )
+    }
+    token_names = ["native", "OLAS"]
+    token_balances = {"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4": {"native": 1.5, "OLAS": 100.0}}
+    list_accounts(accounts, mock_chain_interface, token_names, token_balances)
+    mock_console.print.assert_called_once()
+
+
+def test_list_accounts_empty_with_tokens(mock_console, mock_chain_interface):
+    token_names = ["native"]
+    token_balances = {}  # Should be empty if no accounts
+    list_accounts(None, mock_chain_interface, token_names, token_balances)
+    mock_console.print.assert_called_once()
+
+
+def test_list_accounts_no_accounts_but_tokens(mock_console, mock_chain_interface):
+    token_names = ["native"]
+    token_balances = {"0x5B38Da6a701c568545dCfcB03FcB875f56beddC4": {"native": 1.5}}
+    list_accounts(None, mock_chain_interface, token_names, token_balances)
+    mock_console.print.assert_called_once()