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

tests/test_transaction_service.py

@@ -0,0 +1,161 @@
+"""Tests for TransactionService."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from web3 import exceptions as web3_exceptions
+
+from iwa.core.keys import EncryptedAccount, KeyStorage
+from iwa.core.services.transaction import TransactionService
+
+
+@pytest.fixture
+def mock_key_storage():
+    """Mock key storage."""
+    mock = MagicMock(spec=KeyStorage)
+
+    # Mock sign_transaction
+    mock_signed_tx = MagicMock()
+    mock_signed_tx.raw_transaction = b"raw_tx_bytes"
+    mock.sign_transaction.return_value = mock_signed_tx
+
+    return mock
+
+
+@pytest.fixture
+def mock_account_service():
+    """Mock account service."""
+    mock = MagicMock()
+
+    mock_account = MagicMock(spec=EncryptedAccount)
+    mock_account.address = "0xSigner"
+    mock_account.tag = "signer_tag"
+
+    mock.resolve_account.return_value = mock_account
+    return mock
+
+
+@pytest.fixture
+def mock_chain_interfaces():
+    """Mock chain interfaces."""
+    with patch("iwa.core.services.transaction.ChainInterfaces") as mock:
+        instance = mock.return_value
+        gnosis_interface = MagicMock()
+        gnosis_interface.chain.chain_id = 100
+
+        # Web3 mocks
+        gnosis_interface.web3.eth.get_transaction_count.return_value = 5
+        gnosis_interface.web3.eth.send_raw_transaction.return_value = b"tx_hash_bytes"
+
+        # Receipt valid
+        mock_receipt = MagicMock()
+        mock_receipt.status = 1
+        mock_receipt.gasUsed = 21000
+        mock_receipt.effectiveGasPrice = 10
+        gnosis_interface.web3.eth.wait_for_transaction_receipt.return_value = mock_receipt
+
+        instance.get.return_value = gnosis_interface
+        yield instance
+
+
+@pytest.fixture
+def mock_external_deps():
+    """Mock logger, db, pricing."""
+    with (
+        patch("iwa.core.services.transaction.log_transaction") as mock_log,
+        patch("iwa.core.pricing.PriceService") as mock_price,
+        patch("iwa.core.services.transaction.time.sleep") as _,  # speed up tests
+    ):
+        mock_price.return_value.get_token_price.return_value = 1.0  # 1 EUR per Token
+        yield {
+            "log": mock_log,
+            "price": mock_price,
+        }
+
+
+def test_sign_and_send_success(
+    mock_key_storage, mock_account_service, mock_chain_interfaces, mock_external_deps
+):
+    """Test successful sign and send flow."""
+    service = TransactionService(mock_key_storage, mock_account_service)
+
+    tx = {"to": "0xDest", "value": 100}
+
+    success, receipt = service.sign_and_send(tx, "signer")
+
+    assert success is True
+    assert receipt.status == 1
+
+    # Check flow
+    mock_account_service.resolve_account.assert_called_with("signer")
+    mock_chain_interfaces.get.assert_called_with("gnosis")
+
+    # Check nonce filling
+    mock_chain_interfaces.get.return_value.web3.eth.get_transaction_count.assert_called()
+
+    # Check signing
+    mock_key_storage.sign_transaction.assert_called()
+
+    # Check sending
+    mock_chain_interfaces.get.return_value.web3.eth.send_raw_transaction.assert_called_with(
+        b"raw_tx_bytes"
+    )
+
+    # Check logging
+    mock_external_deps["log"].assert_called_once()
+    call_args = mock_external_deps["log"].call_args[1]
+    assert call_args["tx_hash"] == "74785f686173685f6279746573"  # hex of b'tx_hash_bytes'
+    assert call_args["tags"] is None
+
+
+def test_sign_and_send_low_gas_retry(
+    mock_key_storage, mock_account_service, mock_chain_interfaces, mock_external_deps
+):
+    """Test retry logic on low gas error."""
+    service = TransactionService(mock_key_storage, mock_account_service)
+
+    web3_mock = mock_chain_interfaces.get.return_value.web3.eth
+
+    # First attempt fails with "intrinsic gas too low", second succeeds
+    web3_mock.send_raw_transaction.side_effect = [
+        web3_exceptions.Web3RPCError("intrinsic gas too low"),
+        b"tx_hash_bytes_success",
+    ]
+
+    tx = {"to": "0xDest", "value": 100, "gas": 20000}
+
+    success, receipt = service.sign_and_send(tx, "signer")
+
+    assert success is True
+
+    # Check retries
+    assert web3_mock.send_raw_transaction.call_count == 2
+
+    # Verify gas increase
+    # Since 'tx' is mutated in place, both mock calls point to the same dict object which now has 30000
+    # We can verify that sign_transaction was called twice, and the final gas is 30000
+    assert mock_key_storage.sign_transaction.call_count == 2
+    final_tx_arg = mock_key_storage.sign_transaction.call_args[0][0]
+    assert final_tx_arg["gas"] == 30000
+
+
+def test_sign_and_send_rpc_rotation(
+    mock_key_storage, mock_account_service, mock_chain_interfaces, mock_external_deps
+):
+    """Test RPC rotation on generic error."""
+    service = TransactionService(mock_key_storage, mock_account_service)
+    chain_interface = mock_chain_interfaces.get.return_value
+
+    # Side effect: 1. Exception, 2. Success
+    chain_interface.web3.eth.send_raw_transaction.side_effect = [
+        Exception("Connection reset"),
+        b"tx_hash_bytes",
+    ]
+    chain_interface.rotate_rpc.return_value = True
+
+    tx = {"to": "0xDest", "value": 100}
+
+    success, receipt = service.sign_and_send(tx, "signer")
+
+    assert success is True
+    chain_interface.rotate_rpc.assert_called_once()

tests/test_transfer_multisend.py

@@ -0,0 +1,179 @@
+"""Tests for TransferService.multi_send."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.models import StoredSafeAccount
+from iwa.core.services.transfer import TransferService
+
+
+@pytest.fixture
+def mock_deps():
+    """Mock dependencies for TransferService."""
+    with (
+        patch("iwa.core.services.transfer.base.ChainInterfaces") as mock_chain,
+        patch("iwa.core.services.transfer.multisend.ChainInterfaces", new=mock_chain),
+        patch("iwa.core.services.transfer.swap.ChainInterfaces", new=mock_chain),
+        patch("iwa.core.services.transfer.multisend.MultiSendContract") as mock_ms,
+        patch("iwa.core.services.transfer.multisend.MultiSendCallOnlyContract") as mock_ms_co,
+        patch("iwa.core.services.transfer.multisend.ERC20Contract") as mock_erc20,
+        patch("iwa.core.services.transfer.swap.ERC20Contract", new=mock_erc20),
+        patch("iwa.core.services.transfer.erc20.ERC20Contract", new=mock_erc20),
+    ):
+        mock_account_service = MagicMock()
+        mock_key_storage = MagicMock()
+        mock_balance_service = MagicMock()
+        mock_safe_service = MagicMock()
+        mock_txn_service = MagicMock()
+        # Set default return for sign_and_send
+        mock_txn_service.sign_and_send.return_value = (True, {})
+
+        # Setup Chain Interface
+        mock_w3 = MagicMock()
+        # Ensure to_checksum_address returns input if string
+        mock_w3.to_checksum_address.side_effect = lambda x: x
+        mock_w3.to_wei.return_value = 1000  # 1000 wei default
+        mock_chain.return_value.get.return_value.web3 = mock_w3
+        mock_chain.return_value.get.return_value.chain.name = "gnosis"
+        mock_chain.return_value.get.return_value.chain.tokens = {"TEST": "0xToken"}
+        mock_erc20.return_value.allowance_wei.return_value = 0
+
+        deps = {
+            "account_service": mock_account_service,
+            "key_storage": mock_key_storage,
+            "balance_service": mock_balance_service,
+            "safe_service": mock_safe_service,
+            "transaction_service": mock_txn_service,
+            "contracts": {"ms": mock_ms, "ms_co": mock_ms_co, "erc20": mock_erc20},
+        }
+        yield deps
+
+
+def test_multi_send_eoa_native(mock_deps):
+    """Test multi_send with EOA and native transfers."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    # Mock From Account (EOA)
+    mock_from = MagicMock()
+    mock_from.address = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D"  # Valid checksum address
+    mock_from.tag = "from_tag"
+
+    def resolve_side_effect(arg):
+        if arg == "from_tag":
+            return mock_from
+        return None
+
+    service.account_service.resolve_account.side_effect = resolve_side_effect
+
+    # Mock dependencies
+    mock_ms_co = mock_deps["contracts"]["ms_co"].return_value
+    mock_ms_co.prepare_tx.return_value = {"value": 0, "data": b"encoded"}
+    mock_ms_co.address = "0xMultiSendCallOnly"
+
+    transactions = [
+        {
+            "to": "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB",
+            "amount": 1.0,
+            "token": NATIVE_CURRENCY_ADDRESS,
+        },
+        {"to": "0xTo2", "amount_wei": 500, "token": NATIVE_CURRENCY_ADDRESS},
+    ]
+
+    service.multi_send("from_tag", transactions)
+
+    # Verify Account Resolution
+    # mock_deps["account_service"].resolve_account.assert_called() # Side effect makes called_with tricky
+
+    # Verify Contract Interaction
+    mock_deps["contracts"]["ms_co"].assert_called()
+    mock_ms_co.prepare_tx.assert_called()
+
+    # Verify Transaction Service called
+    mock_deps["transaction_service"].sign_and_send.assert_called()
+
+
+def test_multi_send_safe_erc20(mock_deps):
+    """Test multi_send with Safe and ERC20 transfers."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    # Mock From Account (Safe)
+    mock_safe_account = MagicMock(spec=StoredSafeAccount)
+    mock_safe_account.address = "0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB"
+
+    service.account_service.resolve_account.side_effect = (
+        lambda x: mock_safe_account if x == "safe_tag" else None
+    )
+
+    # Mock ERC20
+    mock_erc20 = mock_deps["contracts"]["erc20"].return_value
+    mock_erc20.decimals = 18
+    mock_erc20.prepare_transfer_tx.return_value = {"data": b"transfer_data"}
+    mock_erc20.address = "0xToken"
+
+    mock_deps["account_service"].get_token_address.return_value = "0xToken"
+
+    # Mock MultiSend Normal (for Safe)
+    mock_ms = mock_deps["contracts"]["ms"].return_value
+    mock_ms.prepare_tx.return_value = {"value": 0, "data": b"multisend_data"}
+    mock_ms.address = "0xMultiSend"
+
+    transactions = [{"to": "0xRecipient", "amount": 10.0, "token": "TEST"}]
+
+    service.multi_send("safe_tag", transactions)
+
+    # Verify ERC20 prep (Safe uses transfer, not transferFrom)
+    mock_erc20.prepare_transfer_tx.assert_called()
+
+    # Verify Safe Service execution
+    mock_deps["safe_service"].execute_safe_transaction.assert_called()
+
+
+def test_multi_send_eoa_erc20_approval(mock_deps):
+    """Test multi_send with EOA checks for allowances."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    # Stub approve_erc20 to verify it's called
+    service.approve_erc20 = MagicMock()
+
+    # Mock From Account (EOA)
+    mock_from = MagicMock()
+    mock_from.address = "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D"
+    del mock_from.threshold  # EOA has no threshold
+    service.account_service.resolve_account.side_effect = (
+        lambda x: mock_from if x == "from_tag" else None
+    )
+
+    mock_deps["account_service"].get_token_address.return_value = "0xToken"
+    mock_erc20 = mock_deps["contracts"]["erc20"].return_value
+    mock_erc20.decimals = 18
+    mock_erc20.prepare_transfer_from_tx.return_value = {"data": b"transferFrom"}
+
+    mock_ms_co = mock_deps["contracts"]["ms_co"].return_value
+    mock_ms_co.prepare_tx.return_value = {"value": 0, "data": b"encoded"}
+
+    transactions = [{"to": "0xRecipient", "amount": 10.0, "token": "TEST"}]
+
+    service.multi_send("from_tag", transactions)
+
+    # Verify Approval logic was triggered
+    service.approve_erc20.assert_called_once()

tests/test_transfer_native.py

@@ -0,0 +1,220 @@
+"""Tests for NativeTransferMixin (wrap/unwrap)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from iwa.core.services.transfer import TransferService
+
+
+@pytest.fixture
+def mock_deps():
+    """Mock dependencies for TransferService."""
+    with (
+        patch("iwa.core.services.transfer.base.ChainInterfaces") as mock_chain,
+        patch("iwa.core.services.transfer.native.ChainInterfaces", new=mock_chain),
+    ):
+        mock_account_service = MagicMock()
+        mock_key_storage = MagicMock()
+        mock_balance_service = MagicMock()
+        mock_safe_service = MagicMock()
+        mock_txn_service = MagicMock()
+
+        # Setup Chain Interface
+        mock_w3 = MagicMock()
+        # Mock eth.contract
+        mock_contract = MagicMock()
+        mock_w3._web3.eth.contract.return_value = mock_contract
+        mock_w3._web3.eth.gas_price = 1000000000
+        mock_w3._web3.eth.get_transaction_count.return_value = 5
+
+        # Mock chain info
+        mock_chain_instance = mock_chain.return_value.get.return_value
+        mock_chain_instance.web3 = mock_w3
+        mock_chain_instance.chain.tokens = {"WXDAI": "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d"}
+
+        deps = {
+            "account_service": mock_account_service,
+            "key_storage": mock_key_storage,
+            "balance_service": mock_balance_service,
+            "safe_service": mock_safe_service,
+            "transaction_service": mock_txn_service,
+            "chain_interface": mock_chain_instance,
+            "contract": mock_contract,
+        }
+        yield deps
+
+
+def test_wrap_native_success(mock_deps):
+    """Test successful wrap of native currency."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    # Mock Account
+    mock_account = MagicMock(name="mock_account")
+    mock_account.address = "0xUser"
+    service.account_service.resolve_account.return_value = mock_account
+
+    # Mock Contract Function build_transaction
+    mock_function = mock_deps["contract"].functions.deposit.return_value
+    mock_function.build_transaction.return_value = {
+        "to": "0xWXDAI",
+        "value": 1000,
+        "data": "0x",
+    }
+
+    # Mock Sign and Send
+    mock_signed_tx = MagicMock()
+    mock_signed_tx.raw_transaction = b"signed_tx"
+    service.key_storage.sign_transaction.return_value = mock_signed_tx
+    mock_deps["chain_interface"].web3._web3.eth.send_raw_transaction.return_value = b"tx_hash"
+
+    # Mock Receipt
+    mock_receipt = MagicMock()
+    mock_receipt.status = 1
+    mock_deps[
+        "chain_interface"
+    ].web3._web3.eth.wait_for_transaction_receipt.return_value = mock_receipt
+
+    result = service.wrap_native("user", 1000)
+
+    assert result == "74785f68617368"  # "tx_hash".hex()
+    mock_deps["contract"].functions.deposit.assert_called()
+    service.key_storage.sign_transaction.assert_called()
+
+
+def test_wrap_native_account_not_found(mock_deps):
+    """Test wrap fails when account not found."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+    service.account_service.resolve_account.return_value = None
+
+    result = service.wrap_native("invalid", 1000)
+    assert result is None
+
+
+def test_wrap_native_token_not_found(mock_deps):
+    """Test wrap fails when WXDAI token not configured."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+    service.account_service.resolve_account.return_value = MagicMock()
+    mock_deps["chain_interface"].chain.tokens = {}  # Empty tokens
+
+    result = service.wrap_native("user", 1000)
+    assert result is None
+
+
+def test_unwrap_native_success(mock_deps):
+    """Test successful unwrap of wrapped token."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    # Mock Account
+    mock_account = MagicMock(name="mock_account")
+    mock_account.address = "0xUser"
+    service.account_service.resolve_account.return_value = mock_account
+
+    # Mock Contract Function build_transaction
+    mock_function = mock_deps["contract"].functions.withdraw.return_value
+    mock_function.build_transaction.return_value = {
+        "to": "0xWXDAI",
+        "data": "0x",
+    }
+
+    # Mock Sign and Send
+    mock_signed_tx = MagicMock()
+    mock_signed_tx.raw_transaction = b"signed_tx"
+    service.key_storage.sign_transaction.return_value = mock_signed_tx
+    mock_deps["chain_interface"].web3._web3.eth.send_raw_transaction.return_value = b"tx_hash"
+
+    # Mock Receipt
+    mock_receipt = MagicMock()
+    mock_receipt.status = 1
+    mock_deps[
+        "chain_interface"
+    ].web3._web3.eth.wait_for_transaction_receipt.return_value = mock_receipt
+
+    result = service.unwrap_native("user", 1000)
+
+    assert result == "74785f68617368"
+    mock_deps["contract"].functions.withdraw.assert_called_with(1000)
+
+
+def test_unwrap_native_auto_balance(mock_deps):
+    """Test unwrap with auto-balance detection."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    mock_account = MagicMock(name="mock_account")
+    mock_account.address = "0xUser"
+    service.account_service.resolve_account.return_value = mock_account
+
+    # Mock Balance
+    mock_deps["balance_service"].get_erc20_balance_wei.return_value = 500
+
+    # Mock Contract Function
+    mock_function = mock_deps["contract"].functions.withdraw.return_value
+    mock_function.build_transaction.return_value = {}
+
+    # Mock Sign/Send/Receipt
+    mock_signed_tx = MagicMock()
+    mock_signed_tx.raw_transaction = b"signed_tx"
+    service.key_storage.sign_transaction.return_value = mock_signed_tx
+    mock_deps["chain_interface"].web3._web3.eth.send_raw_transaction.return_value = b"tx_hash"
+    mock_receipt = MagicMock()
+    mock_receipt.status = 1
+    mock_deps[
+        "chain_interface"
+    ].web3._web3.eth.wait_for_transaction_receipt.return_value = mock_receipt
+
+    # Call without amount
+    result = service.unwrap_native("user")
+
+    assert result == "74785f68617368"
+    mock_deps["balance_service"].get_erc20_balance_wei.assert_called_with(
+        "0xUser", "WXDAI", "gnosis"
+    )
+    mock_deps["contract"].functions.withdraw.assert_called_with(500)
+
+
+def test_unwrap_native_no_balance(mock_deps):
+    """Test unwrap fails when no balance available."""
+    service = TransferService(
+        mock_deps["account_service"],
+        mock_deps["key_storage"],
+        mock_deps["balance_service"],
+        mock_deps["safe_service"],
+        mock_deps["transaction_service"],
+    )
+
+    mock_account = MagicMock()
+    service.account_service.resolve_account.return_value = mock_account
+    mock_deps["balance_service"].get_erc20_balance_wei.return_value = 0
+
+    result = service.unwrap_native("user")
+    assert result is None

tests/test_transfer_security.py

@@ -0,0 +1,93 @@
+"""Security tests for TransferService."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from eth_account import Account
+
+from iwa.core.models import EthereumAddress
+from iwa.core.services.transfer import TransferService
+
+
+@pytest.fixture
+def transfer_service():
+    """Create a TransferService instance with mocked dependencies."""
+    return TransferService(
+        key_storage=MagicMock(),
+        account_service=MagicMock(),
+        balance_service=MagicMock(),
+        safe_service=MagicMock(),
+        transaction_service=MagicMock(),
+    )
+
+
+def test_is_whitelisted_destination_fail_closed(transfer_service):
+    """Verify that destination whitelist fails closed (returns False) by default.
+
+    This addresses TRANS-S1 (Whitelist Bypass).
+    """
+    # 1. Not an internal account
+    transfer_service.account_service.resolve_account.return_value = None
+
+    # 2. No config whitelist (simulating config.core is None or whitelist empty)
+    with patch("iwa.core.services.transfer.base.Config") as mock_config_cls:
+        mock_config = MagicMock()
+        mock_config.core = None  # SIMULATE MISSING CONFIG
+        mock_config_cls.return_value = mock_config
+
+        # Should return False (Blocked)
+        random_addr = Account.create().address
+        assert transfer_service._is_whitelisted_destination(random_addr) is False
+
+
+def test_is_whitelisted_destination_explicit_allow(transfer_service):
+    """Verify that destination whitelist allows explicitly listed addresses."""
+    # 1. Not an internal account
+    transfer_service.account_service.resolve_account.return_value = None
+
+    allowed_addr = Account.create().address
+
+    # 2. In config whitelist
+    with patch("iwa.core.services.transfer.base.Config") as mock_config_cls:
+        mock_config = MagicMock()
+        mock_config.core.whitelist.values.return_value = [EthereumAddress(allowed_addr)]
+        mock_config_cls.return_value = mock_config
+
+        # Should return True (Allowed)
+        assert transfer_service._is_whitelisted_destination(allowed_addr) is True
+
+
+def test_is_supported_token_strict_validation(transfer_service):
+    """Verify that token validation is strict and rejects arbitrary addresses.
+
+    This addresses TRANS-S2 (Explicit Token Whitelist).
+    """
+    chain_name = "Gnosis"
+    valid_token_addr = Account.create().address
+    invalid_token_addr = Account.create().address
+
+    # Mock chain interface
+    mock_chain_interface = MagicMock()
+    mock_chain_interface.tokens = {"OLAS": EthereumAddress(valid_token_addr)}
+
+    with patch("iwa.core.services.transfer.base.ChainInterfaces") as mock_ci_cls:
+        mock_ci_cls.return_value.get.return_value = mock_chain_interface
+
+        # 1. Native currency -> Allowed
+        from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+
+        assert transfer_service._is_supported_token(NATIVE_CURRENCY_ADDRESS, chain_name) is True
+        assert transfer_service._is_supported_token("native", chain_name) is True
+
+        # 2. Explicitly supported token (ByName) -> Allowed
+        assert transfer_service._is_supported_token("OLAS", chain_name) is True
+
+        # 3. Explicitly supported token (ByAddress) -> Allowed
+        assert transfer_service._is_supported_token(valid_token_addr, chain_name) is True
+
+        # 4. Arbitrary address -> BLOCKED
+        # Even if it's a valid ETH address, if it's not in the map, it must be False
+        assert transfer_service._is_supported_token(invalid_token_addr, chain_name) is False
+
+        # 5. Garbage input -> BLOCKED
+        assert transfer_service._is_supported_token("NOT_A_TOKEN", chain_name) is False

tests/test_transfer_structure.py

@@ -0,0 +1,37 @@
+"""Test TransferService structure after refactoring."""
+
+import inspect
+
+from iwa.core.services.transfer import TransferService
+
+
+def test_transfer_service_structure():
+    """Verify TransferService has all expected methods from mixins."""
+    service_methods = dict(inspect.getmembers(TransferService, predicate=inspect.isfunction))
+
+    # Check Base methods
+    assert "_resolve_destination" in service_methods
+    assert "_calculate_gas_info" in service_methods
+
+    # Check Native methods
+    assert "_send_native_via_safe" in service_methods
+    assert "wrap_native" in service_methods
+    assert "unwrap_native" in service_methods
+
+    # Check ERC20 methods
+    assert "_send_erc20_via_safe" in service_methods
+    assert "get_erc20_allowance" in service_methods
+    assert "approve_erc20" in service_methods
+    assert "transfer_from_erc20" in service_methods
+
+    # Check MultiSend/Drain methods
+    assert "multi_send" in service_methods
+    assert "drain" in service_methods
+
+    # Check Swap methods
+    assert "swap" in service_methods
+
+    # Check Main methods
+    assert "send" in service_methods
+
+    print("TransferService structure verification passed!")