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

tests/test_cli.py

@@ -0,0 +1,139 @@
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+
+@pytest.fixture
+def iwa_cli_module():
+    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):
+        if "iwa.core.cli" in sys.modules:
+            del sys.modules["iwa.core.cli"]
+        if "iwa.core.wallet" in sys.modules:
+            pass
+
+        with patch("iwa.core.wallet.Wallet"):
+            import iwa.core.cli
+
+            yield iwa.core.cli.iwa_cli
+
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def cli(iwa_cli_module):
+    return iwa_cli_module
+
+
+@pytest.fixture
+def mock_key_storage():
+    with patch("iwa.core.cli.KeyStorage") as mock:
+        yield mock.return_value
+
+
+@pytest.fixture
+def mock_wallet():
+    with patch("iwa.core.cli.Wallet") as mock:
+        yield mock.return_value
+
+
+def test_account_create(cli, mock_key_storage):
+    result = runner.invoke(cli, ["wallet", "create", "--tag", "test"])
+    assert result.exit_code == 0
+    mock_key_storage.create_account.assert_called_with("test")
+
+
+def test_account_create_error(cli, mock_key_storage):
+    mock_key_storage.create_account.side_effect = ValueError("Error creating account")
+    result = runner.invoke(cli, ["wallet", "create", "--tag", "test"])
+    assert result.exit_code == 1
+    assert "Error: Error creating account" in result.stdout
+
+
+def test_account_list(cli, mock_wallet):
+    mock_wallet.get_accounts_balances.return_value = ({}, None)
+    with (
+        patch("iwa.core.cli.list_accounts") as mock_list_accounts,
+        patch("iwa.core.cli.ChainInterfaces"),
+    ):
+        result = runner.invoke(cli, ["wallet", "list", "--chain", "gnosis", "--balances", "native"])
+        assert result.exit_code == 0
+        mock_wallet.get_accounts_balances.assert_called_with("gnosis", ["native"])
+        mock_list_accounts.assert_called_once()
+
+
+def test_account_send(cli, mock_wallet):
+    result = runner.invoke(
+        cli, ["wallet", "send", "--from", "sender", "--to", "receiver", "--amount", "1.0"]
+    )
+    assert result.exit_code == 0
+    mock_wallet.send.assert_called()
+
+
+def test_erc20_transfer_from(cli, mock_wallet):
+    result = runner.invoke(
+        cli,
+        [
+            "wallet",
+            "transfer-from",
+            "--from",
+            "from",
+            "--sender",
+            "sender",
+            "--recipient",
+            "recipient",
+            "--token",
+            "token",
+            "--amount",
+            "1.0",
+        ],
+    )
+    assert result.exit_code == 0
+    mock_wallet.transfer_from_erc20.assert_called()
+
+
+def test_erc20_approve(cli, mock_wallet):
+    result = runner.invoke(
+        cli,
+        [
+            "wallet",
+            "approve",
+            "--owner",
+            "owner",
+            "--spender",
+            "spender",
+            "--token",
+            "token",
+            "--amount",
+            "1.0",
+        ],
+    )
+    assert result.exit_code == 0
+    mock_wallet.approve_erc20.assert_called()
+
+
+def test_drain_wallet(cli, mock_wallet):
+    result = runner.invoke(cli, ["wallet", "drain", "--from", "from", "--to", "to"])
+    assert result.exit_code == 0
+    mock_wallet.drain.assert_called()

tests/test_contract.py

@@ -0,0 +1,195 @@
+from pathlib import Path
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+from web3.exceptions import ContractCustomError
+
+from iwa.core.contracts.contract import ContractInstance
+
+
+@pytest.fixture
+def mock_chain_interface():
+    with patch("iwa.core.contracts.contract.ChainInterfaces") as mock:
+        mock_ci = mock.return_value.get.return_value
+        mock_ci.web3.eth.contract.return_value = MagicMock()
+        yield mock_ci
+
+
+@pytest.fixture
+def mock_abi_file():
+    abi_content = '[{"type": "function", "name": "testFunc", "inputs": []}, {"type": "error", "name": "CustomError", "inputs": [{"type": "uint256", "name": "code"}]}, {"type": "event", "name": "TestEvent", "inputs": []}]'
+    with patch("builtins.open", mock_open(read_data=abi_content)):
+        yield
+
+
+class MockContract(ContractInstance):
+    name = "test_contract"
+    abi_path = Path("test.json")
+
+
+def test_init(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    assert contract.address == "0xAddress"
+    assert contract.abi is not None
+    assert "0x" in str(contract.error_selectors.keys())  # Check if selector generated
+
+
+def test_init_abi_dict(mock_chain_interface):
+    abi_content = '{"abi": [{"type": "function", "name": "testFunc"}]}'
+    with patch("builtins.open", mock_open(read_data=abi_content)):
+        contract = MockContract("0xAddress", "gnosis")
+        assert contract.abi == [{"type": "function", "name": "testFunc"}]
+
+
+def test_call(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    contract.contract.functions.testFunc.return_value.call.return_value = "result"
+    assert contract.call("testFunc") == "result"
+
+
+def test_prepare_transaction_success(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    mock_chain_interface.calculate_transaction_params.return_value = {"gas": 100}
+    contract.contract.functions.testFunc.return_value.build_transaction.return_value = {
+        "data": "0x"
+    }
+
+    tx = contract.prepare_transaction("testFunc", {}, {})
+    assert tx == {"data": "0x"}
+
+
+def test_prepare_transaction_custom_error_known(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    # Selector for CustomError(uint256)
+    # We need to calculate it or capture what load_error_selectors produced
+    selector = list(contract.error_selectors.keys())[0]  # 0x...
+    # Encode args: uint256(123)
+    encoded_args = "0" * 62 + "7b"  # 123 hex
+    error_data = f"{selector}{encoded_args}"
+
+    contract.contract.functions.testFunc.return_value.build_transaction.side_effect = (
+        ContractCustomError(error_data)
+    )
+
+    # Now the function returns None and logs the error instead of raising
+    with patch("iwa.core.contracts.contract.logger") as mock_logger:
+        result = contract.prepare_transaction("testFunc", {}, {})
+        assert result is None
+        # Verify error was logged
+        mock_logger.error.assert_called()
+
+
+def test_prepare_transaction_custom_error_unknown(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    error_data = "0x12345678"  # Unknown selector
+
+    contract.contract.functions.testFunc.return_value.build_transaction.side_effect = (
+        ContractCustomError(error_data)
+    )
+
+    # Now the function returns None and logs the error instead of raising
+    with patch("iwa.core.contracts.contract.logger") as mock_logger:
+        result = contract.prepare_transaction("testFunc", {}, {})
+        assert result is None
+        # Verify error was logged
+        mock_logger.error.assert_called()
+
+
+def test_prepare_transaction_revert_string(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    # Encoded Error(string) with "Error" as the message
+    encoded_error = "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000054572726f72000000000000000000000000000000000000000000000000000000"
+    e = Exception("msg", encoded_error)
+
+    contract.contract.functions.testFunc.return_value.build_transaction.side_effect = e
+
+    with patch("iwa.core.contracts.contract.logger") as mock_logger:
+        tx = contract.prepare_transaction("testFunc", {}, {})
+        assert tx is None
+        # Should log the decoded error
+        mock_logger.error.assert_called()
+
+
+def test_prepare_transaction_other_exception(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    # The code expects e.args[1] to exist, so we must provide it
+    e = Exception("Generic Error", "Some Data")
+    contract.contract.functions.testFunc.return_value.build_transaction.side_effect = e
+
+    with patch("iwa.core.contracts.contract.logger") as mock_logger:
+        tx = contract.prepare_transaction("testFunc", {}, {})
+        assert tx is None
+        mock_logger.error.assert_called()
+
+
+def test_extract_events(mock_chain_interface, mock_abi_file):
+    contract = MockContract("0xAddress", "gnosis")
+    receipt = MagicMock()
+
+    # Mock event class and its process_receipt method
+    mock_event_instance = MagicMock()
+
+    # Create a log object that supports both ["event"] and .args
+    mock_log = MagicMock()
+    mock_log.__getitem__.side_effect = lambda key: "TestEvent" if key == "event" else None
+    mock_log.args = {"arg1": 1}
+
+    mock_event_instance.process_receipt.return_value = [mock_log]
+    mock_event_class = MagicMock(return_value=mock_event_instance)
+
+    # Mock contract.events dictionary-like access
+    contract.contract.events = MagicMock()
+
+    def get_event(name):
+        if name == "TestEvent":
+            return mock_event_class
+        raise KeyError(name)
+
+    contract.contract.events.__getitem__.side_effect = get_event
+
+    # Explicitly set abi on the mock contract object
+    contract.contract.abi = contract.abi
+
+    events = contract.extract_events(receipt)
+    assert len(events) == 1
+    assert events[0]["name"] == "TestEvent"
+
+
+def test_extract_events_edge_cases(mock_chain_interface):
+    # Custom ABI with multiple event types to test different paths
+    abi_content = '[{"type": "event", "name": "MissingEvent", "inputs": []}, {"type": "event", "name": "EmptyLogsEvent", "inputs": []}, {"type": "event", "name": "ErrorEvent", "inputs": []}, {"type": "function", "name": "NotAnEvent", "inputs": []}]'
+
+    with patch("builtins.open", mock_open(read_data=abi_content)):
+        contract = MockContract("0xAddress", "gnosis")
+
+    receipt = MagicMock()
+
+    # Mock contract.events
+    contract.contract.events = MagicMock()
+
+    # 1. MissingEvent: raises KeyError when accessed
+    # 2. EmptyLogsEvent: returns empty list from process_receipt
+    # 3. ErrorEvent: raises Exception from process_receipt
+
+    mock_empty_logs_event = MagicMock()
+    mock_empty_logs_event.return_value.process_receipt.return_value = []
+
+    mock_error_event = MagicMock()
+    mock_error_event.return_value.process_receipt.side_effect = Exception("Processing error")
+
+    def get_event(name):
+        if name == "MissingEvent":
+            raise KeyError(name)
+        if name == "EmptyLogsEvent":
+            return mock_empty_logs_event
+        if name == "ErrorEvent":
+            return mock_error_event
+        return MagicMock()
+
+    contract.contract.events.__getitem__.side_effect = get_event
+
+    # Explicitly set abi on the mock contract object
+    contract.contract.abi = contract.abi
+
+    events = contract.extract_events(receipt)
+    assert len(events) == 0

tests/test_db.py

@@ -0,0 +1,180 @@
+"""Tests for database operations."""
+
+from unittest.mock import MagicMock, patch
+
+from iwa.core.db import init_db, log_transaction
+
+
+def test_log_transaction_upsert():
+    """Test log_transaction creates new records."""
+    with patch("iwa.core.db.SentTransaction") as mock_model:
+        mock_model.get_or_none.return_value = None
+        mock_insert = mock_model.insert.return_value
+        mock_upsert = mock_insert.on_conflict_replace.return_value
+
+        log_transaction("0x123", "0xFrom", "0xTo", "DAI", 100, "gnosis")
+
+        mock_model.insert.assert_called_once()
+        _, kwargs = mock_model.insert.call_args
+        assert kwargs["tx_hash"] == "0x123"
+        assert kwargs["chain"] == "gnosis"
+
+        mock_upsert.execute.assert_called_once()
+
+
+def test_log_transaction_update_preserve_fields():
+    """Test log_transaction preserves existing non-null fields."""
+    with patch("iwa.core.db.SentTransaction") as mock_model:
+        mock_instance = MagicMock()
+        mock_instance.token = "DAI"
+        mock_instance.value_eur = 10.0
+        mock_instance.amount_wei = "100"
+        mock_model.get_or_none.return_value = mock_instance
+
+        # Update with token="NATIVE" which should be ignored if existing is better
+        log_transaction("0x123", "0xFrom", "0xTo", "NATIVE", 0, "gnosis")
+
+        mock_model.insert.assert_called_once()
+        _, kwargs = mock_model.insert.call_args
+        # Should preserve DAI and 100
+        assert kwargs["token"] == "DAI"
+        assert kwargs["amount_wei"] == "100"
+
+
+def test_log_transaction_error():
+    """Test log_transaction handles errors gracefully."""
+    with (
+        patch("iwa.core.db.SentTransaction") as mock_model,
+        patch("iwa.core.db.logger") as mock_logger,
+    ):
+        mock_model.get_or_none.side_effect = Exception("DB Error")
+
+        log_transaction("0x123", "0xFrom", "0xTo", "DAI", 100, "gnosis")
+
+        mock_logger.error.assert_called()
+
+
+def test_init_db():
+    """Test init_db creates tables and runs migrations."""
+    with (
+        patch("iwa.core.db.db") as mock_db,
+        patch("iwa.core.db.SentTransaction") as mock_model,
+        patch("iwa.core.db.migrate") as mock_migrate,
+        patch("iwa.core.db.SqliteMigrator"),
+    ):
+        mock_db.get_columns.return_value = []
+
+        init_db()
+
+        mock_db.connect.assert_called_once()
+        mock_db.create_tables.assert_called_with([mock_model], safe=True)
+        assert mock_migrate.call_count >= 1
+
+
+def test_init_db_closed_at_end():
+    """Test init_db closes connection at end."""
+    with (
+        patch("iwa.core.db.db") as mock_db,
+        patch("iwa.core.db.SentTransaction"),
+        patch("iwa.core.db.migrate"),
+        patch("iwa.core.db.SqliteMigrator"),
+    ):
+        mock_db.is_closed.side_effect = [True, False]  # closed initially, then open
+        mock_db.get_columns.return_value = []
+
+        init_db()
+
+        mock_db.close.assert_called_once()
+
+
+def test_init_db_get_columns_error():
+    """Test init_db handles get_columns error."""
+    with (
+        patch("iwa.core.db.db") as mock_db,
+        patch("iwa.core.db.SentTransaction"),
+    ):
+        mock_db.get_columns.side_effect = Exception("Table not found")
+
+        # Should not raise
+        init_db()
+
+
+def test_run_migrations_drop_token_symbol():
+    """Test run_migrations drops deprecated token_symbol column."""
+    from iwa.core.db import run_migrations
+
+    with patch("iwa.core.db.SqliteMigrator"), patch("iwa.core.db.migrate") as mock_migrate:
+        columns = ["token_symbol", "from_tag", "price_eur", "tags"]
+
+        run_migrations(columns)
+
+        # Should have called migrate to drop token_symbol
+        assert mock_migrate.called
+
+
+def test_run_migrations_drop_token_symbol_error():
+    """Test run_migrations handles drop_column error."""
+    from iwa.core.db import run_migrations
+
+    with (
+        patch("iwa.core.db.SqliteMigrator"),
+        patch("iwa.core.db.migrate", side_effect=Exception("Drop failed")),
+        patch("iwa.core.db.logger") as mock_logger,
+    ):
+        columns = ["token_symbol", "from_tag", "price_eur", "tags"]
+
+        run_migrations(columns)
+
+        mock_logger.warning.assert_called()
+
+
+def test_run_migrations_add_from_tag():
+    """Test run_migrations adds from_tag columns."""
+    from iwa.core.db import run_migrations
+
+    with patch("iwa.core.db.SqliteMigrator"), patch("iwa.core.db.migrate") as mock_migrate:
+        columns = ["price_eur", "tags"]  # No from_tag
+
+        run_migrations(columns)
+
+        assert mock_migrate.called
+
+
+def test_run_migrations_add_from_tag_error():
+    """Test run_migrations handles add_column error."""
+    from iwa.core.db import run_migrations
+
+    with (
+        patch("iwa.core.db.SqliteMigrator"),
+        patch("iwa.core.db.migrate", side_effect=Exception("Add failed")),
+        patch("iwa.core.db.logger") as mock_logger,
+    ):
+        columns = []  # No columns - triggers add
+
+        run_migrations(columns)
+
+        mock_logger.warning.assert_called()
+
+
+def test_run_migrations_add_price_eur():
+    """Test run_migrations adds price columns."""
+    from iwa.core.db import run_migrations
+
+    with patch("iwa.core.db.SqliteMigrator"), patch("iwa.core.db.migrate") as mock_migrate:
+        columns = ["from_tag", "tags"]  # No price_eur
+
+        run_migrations(columns)
+
+        assert mock_migrate.called
+
+
+def test_run_migrations_add_tags():
+    """Test run_migrations adds tags column."""
+    from iwa.core.db import run_migrations
+
+    with patch("iwa.core.db.SqliteMigrator"), patch("iwa.core.db.migrate") as mock_migrate:
+        columns = ["from_tag", "price_eur"]  # No tags
+
+        run_migrations(columns)
+
+        assert mock_migrate.called

tests/test_drain_coverage.py

@@ -0,0 +1,174 @@
+"""Tests for DrainManagerMixin coverage."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.plugins.olas.contracts.staking import StakingState
+
+
+@pytest.fixture
+def mock_drain_manager():
+    """Create a mock DrainManagerMixin instance."""
+    from iwa.plugins.olas.service_manager.drain import DrainManagerMixin
+
+    class MockManager(DrainManagerMixin):
+        def __init__(self):
+            self.wallet = MagicMock()
+            self.service = MagicMock()
+            self.chain_name = "gnosis"
+            self.olas_config = MagicMock()
+
+    return MockManager()
+
+
+def test_claim_rewards_no_service(mock_drain_manager):
+    """Test claim_rewards with no active service."""
+    mock_drain_manager.service = None
+    success, amount = mock_drain_manager.claim_rewards()
+    assert not success
+    assert amount == 0
+
+
+def test_claim_rewards_not_staked(mock_drain_manager):
+    """Test claim_rewards when service is not staked."""
+    mock_drain_manager.service.staking_contract_address = None
+    success, amount = mock_drain_manager.claim_rewards()
+    assert not success
+    assert amount == 0
+
+
+def test_claim_rewards_claim_tx_fails(mock_drain_manager):
+    """Test claim_rewards when prepare_claim_tx fails."""
+    mock_drain_manager.service.staking_contract_address = "0xStaking"
+    mock_drain_manager.service.service_id = 1
+
+    with patch("iwa.plugins.olas.service_manager.drain.StakingContract") as mock_staking_cls:
+        mock_staking = mock_staking_cls.return_value
+        mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.get_accrued_rewards.return_value = 1000000000000000000
+        mock_staking.prepare_claim_tx.return_value = None  # Failed to prepare
+
+        success, amount = mock_drain_manager.claim_rewards()
+        assert not success
+        assert amount == 0
+
+
+def test_claim_rewards_send_fails(mock_drain_manager):
+    """Test claim_rewards when transaction send fails."""
+    mock_drain_manager.service.staking_contract_address = "0xStaking"
+    mock_drain_manager.service.service_id = 1
+    mock_drain_manager.wallet.master_account.address = "0xMaster"
+
+    with patch("iwa.plugins.olas.service_manager.drain.StakingContract") as mock_staking_cls:
+        mock_staking = mock_staking_cls.return_value
+        mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.get_accrued_rewards.return_value = 1000000000000000000
+        mock_staking.prepare_claim_tx.return_value = {"to": "0x", "data": "0x"}
+        mock_drain_manager.wallet.sign_and_send_transaction.return_value = (False, None)
+
+        success, amount = mock_drain_manager.claim_rewards()
+        assert not success
+        assert amount == 0
+
+
+def test_claim_rewards_success_no_event(mock_drain_manager):
+    """Test claim_rewards success but no RewardClaimed event."""
+    mock_drain_manager.service.staking_contract_address = "0xStaking"
+    mock_drain_manager.service.service_id = 1
+    mock_drain_manager.wallet.master_account.address = "0xMaster"
+
+    with patch("iwa.plugins.olas.service_manager.drain.StakingContract") as mock_staking_cls:
+        mock_staking = mock_staking_cls.return_value
+        mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.get_accrued_rewards.return_value = 1000000000000000000
+        mock_staking.prepare_claim_tx.return_value = {"to": "0x", "data": "0x"}
+        mock_staking.extract_events.return_value = []  # No RewardClaimed event
+        mock_drain_manager.wallet.sign_and_send_transaction.return_value = (
+            True,
+            {"transactionHash": "0xHash"},
+        )
+
+        success, amount = mock_drain_manager.claim_rewards()
+        assert success
+        assert amount == 1000000000000000000
+
+
+def test_withdraw_rewards_no_withdrawal_address(mock_drain_manager):
+    """Test withdraw_rewards with no withdrawal address configured."""
+    mock_drain_manager.service.multisig_address = "0xSafe"
+    mock_drain_manager.olas_config.withdrawal_address = None
+
+    success, amount = mock_drain_manager.withdraw_rewards()
+    assert not success
+    assert amount == 0
+
+
+def test_drain_service_no_service(mock_drain_manager):
+    """Test drain_service with no active service."""
+    mock_drain_manager.service = None
+    result = mock_drain_manager.drain_service()
+    assert result == {}
+
+
+def test_claim_rewards_if_needed_exception(mock_drain_manager):
+    """Test _claim_rewards_if_needed handles exceptions."""
+    mock_drain_manager.service.staking_contract_address = "0xStaking"
+
+    # Mock claim_rewards to raise
+    mock_drain_manager.claim_rewards = MagicMock(side_effect=Exception("Test Error"))
+
+    result = mock_drain_manager._claim_rewards_if_needed(claim_rewards=True)
+    assert result == 0
+
+
+def test_drain_agent_account_exception(mock_drain_manager):
+    """Test _drain_agent_account handles drain exceptions."""
+    mock_drain_manager.service.agent_address = "0xAgent"
+    mock_drain_manager.wallet.drain.side_effect = Exception("Drain failed")
+
+    result = mock_drain_manager._drain_agent_account("0xTarget", "gnosis")
+    assert result is None
+
+
+def test_drain_owner_account_exception(mock_drain_manager):
+    """Test _drain_owner_account handles drain exceptions."""
+    mock_drain_manager.service.service_owner_address = "0xOwner"
+    mock_drain_manager.wallet.drain.side_effect = Exception("Drain failed")
+
+    result = mock_drain_manager._drain_owner_account("0xTarget", "gnosis")
+    assert result is None
+
+
+def test_normalize_drain_result_tuple(mock_drain_manager):
+    """Test _normalize_drain_result with tuple input."""
+
+    # Success tuple with HexBytes-like object
+    class FakeHexBytes:
+        def hex(self):
+            return "0xABCDEF"
+
+    result = mock_drain_manager._normalize_drain_result((True, {"transactionHash": FakeHexBytes()}))
+    assert result == "0xABCDEF"
+
+
+def test_normalize_drain_result_failure_tuple(mock_drain_manager):
+    """Test _normalize_drain_result with failure tuple."""
+    result = mock_drain_manager._normalize_drain_result((False, {}))
+    assert result is None
+
+
+def test_normalize_drain_result_none(mock_drain_manager):
+    """Test _normalize_drain_result with None input."""
+    result = mock_drain_manager._normalize_drain_result(None)
+    assert result is None
+
+
+def test_drain_owner_skipped_when_equals_target(mock_drain_manager):
+    """Test _drain_owner_account is skipped when owner == target."""
+    mock_drain_manager.service.service_owner_address = "0xOwner123"
+    # Target is the same as owner (case-insensitive)
+    result = mock_drain_manager._drain_owner_account("0xowner123", "gnosis")
+    # Should skip and return None without calling drain
+    assert result is None
+    mock_drain_manager.wallet.drain.assert_not_called()