iwa 0.0.59__py3-none-any.whl → 0.0.61__py3-none-any.whl

tests/test_safe_executor.py

@@ -359,3 +359,211 @@ def test_retry_preserves_gas(executor, mock_chain_interface, mock_safe_tx, mock_
             executor.execute_with_retry("0xSafe", mock_safe_tx, ["key1"])
 
         assert mock_safe_tx.safe_tx_gas == original_gas
+
+
+# =============================================================================
+# Test: Gas estimation (_estimate_safe_tx_gas)
+# =============================================================================
+
+
+def test_estimate_safe_tx_gas_with_buffer(executor, mock_safe):
+    """Test gas estimation applies buffer correctly."""
+    mock_safe.estimate_tx_gas.return_value = 100_000
+    mock_safe_tx = MagicMock()
+    mock_safe_tx.to = "0xDest"
+    mock_safe_tx.value = 0
+    mock_safe_tx.data = b""
+    mock_safe_tx.operation = 0
+
+    result = executor._estimate_safe_tx_gas(mock_safe, mock_safe_tx)
+
+    # Default buffer is 1.5, so 100000 * 1.5 = 150000
+    assert result == 150_000
+
+
+def test_estimate_safe_tx_gas_caps_at_10x(executor, mock_safe):
+    """Test gas estimation respects x10 cap when base_estimate is provided."""
+    mock_safe.estimate_tx_gas.return_value = 500_000  # High estimate
+    mock_safe_tx = MagicMock()
+    mock_safe_tx.to = "0xDest"
+    mock_safe_tx.value = 0
+    mock_safe_tx.data = b""
+    mock_safe_tx.operation = 0
+
+    # 500000 * 1.5 = 750000, but base_estimate * 10 = 50000
+    result = executor._estimate_safe_tx_gas(mock_safe, mock_safe_tx, base_estimate=5_000)
+
+    # Should be capped at 5000 * 10 = 50000
+    assert result == 50_000
+
+
+def test_estimate_safe_tx_gas_fallback_on_failure(executor, mock_safe):
+    """Test gas estimation uses fallback when estimation fails."""
+    mock_safe.estimate_tx_gas.side_effect = Exception("Estimation failed")
+    mock_safe_tx = MagicMock()
+    mock_safe_tx.to = "0xDest"
+    mock_safe_tx.value = 0
+    mock_safe_tx.data = b""
+    mock_safe_tx.operation = 0
+
+    result = executor._estimate_safe_tx_gas(mock_safe, mock_safe_tx)
+
+    assert result == executor.DEFAULT_FALLBACK_GAS
+
+
+# =============================================================================
+# Test: Error decoding (_decode_revert_reason)
+# =============================================================================
+
+
+def test_decode_revert_reason_with_hex_data(executor):
+    """Test decoding when error contains hex data."""
+    # Create an error with hex data that might be decodable
+    error = ValueError("execution reverted: 0x08c379a0...")
+
+    with patch("iwa.core.services.safe_executor.ErrorDecoder") as mock_decoder:
+        mock_decoder.return_value.decode.return_value = [("Error", "Insufficient balance", "ERC20")]
+        result = executor._decode_revert_reason(error)
+
+    # Note: Due to hex matching, this should find the data and attempt decode
+    assert result == "Insufficient balance (from ERC20)"
+
+
+def test_decode_revert_reason_no_hex_data(executor):
+    """Test decoding when error has no hex data."""
+    error = ValueError("Some generic error without hex")
+
+    result = executor._decode_revert_reason(error)
+
+    assert result is None
+
+
+def test_decode_revert_reason_decode_fails(executor):
+    """Test decoding when decoder returns None."""
+    error = ValueError("error: 0xdeadbeef")
+
+    with patch("iwa.core.services.safe_executor.ErrorDecoder") as mock_decoder:
+        mock_decoder.return_value.decode.return_value = None
+        result = executor._decode_revert_reason(error)
+
+    assert result is None
+
+
+# =============================================================================
+# Test: Error classification
+# =============================================================================
+
+
+def test_classify_error_gas_error(executor):
+    """Test classification of gas-related errors."""
+    error = ValueError("intrinsic gas too low")
+    result = executor._classify_error(error)
+
+    assert result["is_gas_error"] is True
+    assert result["is_nonce_error"] is False
+
+
+def test_classify_error_revert(executor):
+    """Test classification of revert errors."""
+    error = ValueError("execution reverted: some reason")
+    result = executor._classify_error(error)
+
+    assert result["is_revert"] is True
+
+
+def test_classify_error_out_of_gas(executor):
+    """Test classification of out of gas errors."""
+    error = ValueError("out of gas")
+    result = executor._classify_error(error)
+
+    assert result["is_gas_error"] is True
+
+
+# =============================================================================
+# Test: Transaction failures
+# =============================================================================
+
+
+def test_transaction_reverts_onchain(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """Test handling when transaction is mined but reverts (status 0)."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.return_value = b"tx_hash"
+        # Receipt with status 0 (reverted)
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=0
+        )
+
+        with patch("time.sleep"):
+            success, error, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        assert success is False
+        assert "reverted" in error.lower()
+
+
+def test_check_receipt_status_dict_format(executor):
+    """Test receipt status check with dict-style receipt."""
+    # Dict-style receipt (not MagicMock)
+    receipt_dict = {"status": 1, "gasUsed": 21000}
+    assert executor._check_receipt_status(receipt_dict) is True
+
+    receipt_dict_failed = {"status": 0}
+    assert executor._check_receipt_status(receipt_dict_failed) is False
+
+
+def test_simulation_revert_not_nonce(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """Test handling when simulation reverts with non-nonce error."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        # Simulation fails with generic revert
+        mock_safe_tx.call.side_effect = ValueError("execution reverted: insufficient funds")
+
+        with patch("time.sleep"):
+            success, error, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        assert success is False
+        assert "insufficient funds" in error.lower() or "reverted" in error.lower()
+
+
+def test_gas_error_strategy_triggers_retry(
+    executor, mock_chain_interface, mock_safe_tx, mock_safe
+):
+    """Test that gas errors trigger retry with gas increase strategy."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.side_effect = [
+            ValueError("intrinsic gas too low"),
+            b"tx_hash",
+        ]
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
+
+        with patch("time.sleep"):
+            success, tx_hash, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        # Should have retried and succeeded
+        assert success is True
+        assert mock_safe_tx.execute.call_count == 2
+
+
+def test_rpc_rotation_stops_when_should_not_retry(
+    executor, mock_chain_interface, mock_safe_tx, mock_safe
+):
+    """Test that execution stops when RPC handler says not to retry."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        mock_safe_tx.execute.side_effect = ValueError("Rate limit exceeded")
+        mock_chain_interface._is_rate_limit_error.return_value = True
+        mock_chain_interface._handle_rpc_error.return_value = {"should_retry": False}
+
+        with patch("time.sleep"):
+            success, error, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        assert success is False
+        # Only 1 attempt because should_retry=False
+        assert mock_safe_tx.execute.call_count == 1

tests/test_transaction_service.py

@@ -1,12 +1,17 @@
-"""Tests for TransactionService."""
+"""Tests for TransactionService and TransferLogger."""
 
 from unittest.mock import MagicMock, patch
 
 import pytest
+from web3 import Web3
 from web3 import exceptions as web3_exceptions
 
 from iwa.core.keys import EncryptedAccount, KeyStorage
-from iwa.core.services.transaction import TransactionService
+from iwa.core.services.transaction import (
+    TRANSFER_EVENT_TOPIC,
+    TransactionService,
+    TransferLogger,
+)
 
 
 @pytest.fixture
@@ -177,3 +182,174 @@ def test_sign_and_send_rpc_rotation(
     assert success is True
     # Verify retry happened - send_raw_transaction called twice
     assert chain_interface.web3.eth.send_raw_transaction.call_count == 2
+
+
+# =============================================================================
+# TransferLogger tests
+# =============================================================================
+
+# Real-world address for tests
+_ADDR = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+_ADDR_LOWER = _ADDR.lower()
+# 32-byte topic with address in last 20 bytes
+_TOPIC_BYTES = b"\x00" * 12 + bytes.fromhex(_ADDR_LOWER[2:])
+_TOPIC_HEX_STR = "0x" + "0" * 24 + _ADDR_LOWER[2:]
+
+
+@pytest.fixture
+def transfer_logger():
+    """Create a TransferLogger with minimal mocks."""
+    account_service = MagicMock()
+    account_service.get_tag_by_address.return_value = None
+    chain_interface = MagicMock()
+    chain_interface.chain.native_currency = "xDAI"
+    chain_interface.chain.get_token_name.return_value = None
+    chain_interface.get_token_decimals.return_value = 18
+    return TransferLogger(account_service, chain_interface)
+
+
+class TestTopicToAddress:
+    """Test TransferLogger._topic_to_address with all input types."""
+
+    def test_bytes_topic(self, transfer_logger):
+        """32 bytes → last 20 bytes extracted as address."""
+        result = transfer_logger._topic_to_address(_TOPIC_BYTES)
+        assert result == Web3.to_checksum_address(_ADDR_LOWER)
+
+    def test_hex_string_topic(self, transfer_logger):
+        """Hex string with 0x prefix → last 40 chars as address."""
+        result = transfer_logger._topic_to_address(_TOPIC_HEX_STR)
+        assert result == Web3.to_checksum_address(_ADDR_LOWER)
+
+    def test_hex_string_no_prefix(self, transfer_logger):
+        """Hex string without 0x prefix."""
+        topic = "0" * 24 + _ADDR_LOWER[2:]
+        result = transfer_logger._topic_to_address(topic)
+        assert result == Web3.to_checksum_address(_ADDR_LOWER)
+
+    def test_hexbytes_like_topic(self, transfer_logger):
+        """Object with .hex() method (like HexBytes)."""
+
+        class FakeHexBytes:
+            def hex(self):
+                return "0" * 24 + _ADDR_LOWER[2:]
+
+        result = transfer_logger._topic_to_address(FakeHexBytes())
+        assert result == Web3.to_checksum_address(_ADDR_LOWER)
+
+    def test_unsupported_type_returns_empty(self, transfer_logger):
+        """Non-bytes, non-str, no .hex() → empty string."""
+        result = transfer_logger._topic_to_address(12345)
+        assert result == ""
+
+
+class TestProcessLog:
+    """Test TransferLogger._process_log with realistic log structures."""
+
+    def _make_transfer_log(self, from_addr, to_addr, amount_wei, token_addr="0xToken"):
+        """Build a dict-style Transfer event log."""
+        from_topic = "0x" + "0" * 24 + from_addr[2:].lower()
+        to_topic = "0x" + "0" * 24 + to_addr[2:].lower()
+        data = amount_wei.to_bytes(32, "big")
+        return {
+            "topics": [TRANSFER_EVENT_TOPIC, from_topic, to_topic],
+            "data": data,
+            "address": token_addr,
+        }
+
+    def test_parses_erc20_transfer(self, transfer_logger):
+        """Valid Transfer log is parsed and logged."""
+        log = self._make_transfer_log(
+            "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+            10**18,  # 1 token with 18 decimals
+        )
+        # Should not raise
+        transfer_logger._process_log(log)
+
+    def test_ignores_non_transfer_event(self, transfer_logger):
+        """Log with non-Transfer topic is silently skipped."""
+        log = {
+            "topics": ["0xdeadbeef" + "0" * 56],
+            "data": b"",
+            "address": "0xToken",
+        }
+        # Should not raise or log anything
+        transfer_logger._process_log(log)
+
+    def test_ignores_log_with_no_topics(self, transfer_logger):
+        """Log with empty topics is skipped."""
+        transfer_logger._process_log({"topics": [], "data": b""})
+
+    def test_ignores_log_with_insufficient_topics(self, transfer_logger):
+        """Transfer event with < 3 topics (missing from/to) is skipped."""
+        log = {
+            "topics": [TRANSFER_EVENT_TOPIC, "0x" + "0" * 64],
+            "data": b"",
+            "address": "0xToken",
+        }
+        transfer_logger._process_log(log)
+
+    def test_handles_bytes_topics(self, transfer_logger):
+        """Log with bytes topics (not hex strings)."""
+        from_bytes = b"\x00" * 12 + b"\xAA" * 20
+        to_bytes = b"\x00" * 12 + b"\xBB" * 20
+        event_topic = bytes.fromhex(TRANSFER_EVENT_TOPIC[2:])
+        log = {
+            "topics": [event_topic, from_bytes, to_bytes],
+            "data": (100).to_bytes(32, "big"),
+            "address": "0xTokenAddr",
+        }
+        transfer_logger._process_log(log)
+
+    def test_handles_string_data(self, transfer_logger):
+        """Log with hex-encoded data string instead of bytes."""
+        log = self._make_transfer_log(
+            "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
+            "0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+            0,
+        )
+        log["data"] = "0x" + "0" * 64  # String instead of bytes
+        transfer_logger._process_log(log)
+
+
+class TestResolveLabels:
+    """Test address/token label resolution fallbacks."""
+
+    def test_address_label_known_wallet(self, transfer_logger):
+        """Known wallet tag is preferred."""
+        transfer_logger.account_service.get_tag_by_address.return_value = "my_safe"
+        result = transfer_logger._resolve_address_label("0xABC")
+        assert result == "my_safe"
+
+    def test_address_label_known_token(self, transfer_logger):
+        """Falls back to token contract name."""
+        transfer_logger.account_service.get_tag_by_address.return_value = None
+        transfer_logger.chain_interface.chain.get_token_name.return_value = "OLAS"
+        result = transfer_logger._resolve_address_label("0xOLAS")
+        assert result == "OLAS_contract"
+
+    def test_address_label_abbreviated(self, transfer_logger):
+        """Falls back to abbreviated address."""
+        result = transfer_logger._resolve_address_label("0xABCDEF1234567890ABCDEF")
+        assert result.startswith("0xABCD")
+        assert result.endswith("CDEF")
+        assert "..." in result
+
+    def test_address_label_empty(self, transfer_logger):
+        """Empty address returns 'unknown'."""
+        assert transfer_logger._resolve_address_label("") == "unknown"
+
+    def test_token_label_known(self, transfer_logger):
+        """Known token returns its name."""
+        transfer_logger.chain_interface.chain.get_token_name.return_value = "OLAS"
+        assert transfer_logger._resolve_token_label("0xOLAS") == "OLAS"
+
+    def test_token_label_unknown(self, transfer_logger):
+        """Unknown token returns abbreviated address."""
+        result = transfer_logger._resolve_token_label("0xABCDEF1234567890ABCDEF")
+        assert "..." in result
+
+    def test_token_label_empty(self, transfer_logger):
+        """Empty address returns 'UNKNOWN'."""
+        assert transfer_logger._resolve_token_label("") == "UNKNOWN"