iwa 0.0.60__py3-none-any.whl → 0.0.62__py3-none-any.whl

tests/test_chainlist_enrichment.py

@@ -0,0 +1,354 @@
+"""Tests for ChainList RPC enrichment and quality probing."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+import requests
+
+from iwa.core.chainlist import (
+    ChainlistRPC,
+    RPCNode,
+    _is_template_url,
+    _normalize_url,
+    probe_rpc,
+)
+
+
+@pytest.fixture(autouse=True)
+def mock_chainlist_enrichment():
+    """Override conftest — allow real enrichment calls in this test file."""
+    yield
+
+
+class TestNormalizeUrl:
+    """Test URL normalization for deduplication."""
+
+    def test_strips_trailing_slash(self):
+        assert _normalize_url("https://rpc.example.com/") == "https://rpc.example.com"
+
+    def test_lowercases(self):
+        assert _normalize_url("https://RPC.Example.COM") == "https://rpc.example.com"
+
+    def test_no_change_needed(self):
+        assert _normalize_url("https://rpc.example.com") == "https://rpc.example.com"
+
+
+class TestIsTemplateUrl:
+    """Test template URL detection."""
+
+    def test_dollar_brace(self):
+        assert _is_template_url("https://rpc.example.com/${API_KEY}") is True
+
+    def test_plain_brace(self):
+        assert _is_template_url("https://rpc.example.com/{api_key}") is True
+
+    def test_no_template(self):
+        assert _is_template_url("https://rpc.example.com") is False
+
+
+class TestProbeRpc:
+    """Test single RPC probing."""
+
+    @pytest.fixture
+    def mock_session(self):
+        """Create a mock session for probe_rpc tests."""
+        with patch("iwa.core.chainlist.requests.Session") as mock_session_cls:
+            mock_session = MagicMock()
+            mock_session_cls.return_value = mock_session
+            # Make it work as context manager too
+            mock_session.__enter__ = MagicMock(return_value=mock_session)
+            mock_session.__exit__ = MagicMock(return_value=False)
+            yield mock_session
+
+    def test_success(self, mock_session):
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"jsonrpc": "2.0", "result": "0x1A4B5C", "id": 1}
+        mock_session.post.return_value = mock_resp
+
+        result = probe_rpc("https://rpc.example.com")
+
+        assert result is not None
+        url, latency, block = result
+        assert url == "https://rpc.example.com"
+        assert latency > 0
+        assert block == 0x1A4B5C
+        # Verify session was closed
+        mock_session.close.assert_called_once()
+
+    def test_timeout_returns_none(self, mock_session):
+        mock_session.post.side_effect = requests.exceptions.Timeout("timed out")
+
+        result = probe_rpc("https://slow.example.com")
+        assert result is None
+        # Session still closed on error
+        mock_session.close.assert_called_once()
+
+    def test_connection_error_returns_none(self, mock_session):
+        mock_session.post.side_effect = requests.exceptions.ConnectionError("refused")
+
+        result = probe_rpc("https://dead.example.com")
+        assert result is None
+        mock_session.close.assert_called_once()
+
+    def test_zero_block_returns_none(self, mock_session):
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"jsonrpc": "2.0", "result": "0x0", "id": 1}
+        mock_session.post.return_value = mock_resp
+
+        result = probe_rpc("https://rpc.example.com")
+        assert result is None
+
+    def test_null_result_returns_none(self, mock_session):
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"jsonrpc": "2.0", "result": None, "id": 1}
+        mock_session.post.return_value = mock_resp
+
+        result = probe_rpc("https://rpc.example.com")
+        assert result is None
+
+    def test_error_response_returns_none(self, mock_session):
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {
+            "jsonrpc": "2.0",
+            "error": {"code": -32600, "message": "Invalid Request"},
+            "id": 1,
+        }
+        mock_session.post.return_value = mock_resp
+
+        result = probe_rpc("https://rpc.example.com")
+        assert result is None
+
+    def test_uses_provided_session(self):
+        """When a session is provided, use it instead of creating one."""
+        provided_session = MagicMock()
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"jsonrpc": "2.0", "result": "0x100", "id": 1}
+        provided_session.post.return_value = mock_resp
+
+        result = probe_rpc("https://rpc.example.com", session=provided_session)
+
+        assert result is not None
+        provided_session.post.assert_called_once()
+        # Should NOT close provided session (caller's responsibility)
+        provided_session.close.assert_not_called()
+
+
+class TestGetValidatedRpcs:
+    """Test ChainlistRPC.get_validated_rpcs()."""
+
+    def _make_node(self, url, tracking="none"):
+        return RPCNode(url=url, is_working=True, tracking=tracking)
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_filters_template_urls(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("https://rpc.example.com/${API_KEY}"),
+            self._make_node("https://good.example.com"),
+        ]
+        mock_probe.return_value = ("https://good.example.com", 50.0, 1000)
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        assert result == ["https://good.example.com"]
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_filters_non_https(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("http://insecure.example.com"),
+            self._make_node("wss://ws.example.com"),
+            self._make_node("https://good.example.com"),
+        ]
+        mock_probe.return_value = ("https://good.example.com", 50.0, 1000)
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        assert result == ["https://good.example.com"]
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_deduplicates_existing(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("https://already.configured.com"),
+            self._make_node("https://new.example.com"),
+        ]
+        mock_probe.return_value = ("https://new.example.com", 50.0, 1000)
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(
+            100, existing_rpcs=["https://already.configured.com/"]
+        )
+
+        assert result == ["https://new.example.com"]
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_filters_stale_rpcs(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("https://fresh.example.com"),
+            self._make_node("https://stale.example.com"),
+            self._make_node("https://also-fresh.example.com"),
+        ]
+        # fresh=1000, stale=900 (100 blocks behind), also-fresh=999
+        mock_probe.side_effect = [
+            ("https://fresh.example.com", 50.0, 1000),
+            ("https://stale.example.com", 30.0, 900),
+            ("https://also-fresh.example.com", 60.0, 999),
+        ]
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        # Stale RPC (900) is 100 blocks behind median (999) > MAX_BLOCK_LAG
+        assert "https://stale.example.com" not in result
+        assert "https://fresh.example.com" in result
+        assert "https://also-fresh.example.com" in result
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_sorts_by_latency(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("https://slow.example.com"),
+            self._make_node("https://fast.example.com"),
+            self._make_node("https://medium.example.com"),
+        ]
+        mock_probe.side_effect = [
+            ("https://slow.example.com", 200.0, 1000),
+            ("https://fast.example.com", 10.0, 1000),
+            ("https://medium.example.com", 80.0, 1000),
+        ]
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        assert result == [
+            "https://fast.example.com",
+            "https://medium.example.com",
+            "https://slow.example.com",
+        ]
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_respects_max_results(self, mock_probe, mock_get_rpcs):
+        nodes = [self._make_node(f"https://rpc{i}.example.com") for i in range(10)]
+        mock_get_rpcs.return_value = nodes
+        mock_probe.side_effect = [
+            (f"https://rpc{i}.example.com", float(i * 10), 1000) for i in range(10)
+        ]
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[], max_results=3)
+
+        assert len(result) == 3
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    def test_returns_empty_on_no_rpcs(self, mock_get_rpcs):
+        mock_get_rpcs.return_value = []
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        assert result == []
+
+    @patch.object(ChainlistRPC, "get_rpcs")
+    @patch("iwa.core.chainlist.probe_rpc")
+    def test_returns_empty_when_all_probes_fail(self, mock_probe, mock_get_rpcs):
+        mock_get_rpcs.return_value = [
+            self._make_node("https://dead1.example.com"),
+            self._make_node("https://dead2.example.com"),
+        ]
+        mock_probe.return_value = None
+
+        cl = ChainlistRPC()
+        result = cl.get_validated_rpcs(100, existing_rpcs=[])
+
+        assert result == []
+
+
+class TestEnrichFromChainlist:
+    """Test ChainInterface._enrich_rpcs_from_chainlist().
+
+    The conftest fixture is overridden in this file so the real
+    enrichment method runs during __init__.
+    """
+
+    @patch("iwa.core.chain.interface.Web3")
+    def test_skipped_for_tenderly(self, mock_web3):
+        from iwa.core.chain.interface import ChainInterface
+        from iwa.core.chain.models import SupportedChain
+
+        chain = MagicMock(spec=SupportedChain)
+        chain.name = "TestChain"
+        chain.rpcs = ["https://virtual.tenderly.co/test"]
+        chain.rpc = "https://virtual.tenderly.co/test"
+        chain.chain_id = 100
+
+        with patch("iwa.core.chainlist.ChainlistRPC") as mock_cl_cls:
+            ci = ChainInterface(chain)
+
+        # is_tenderly=True → enrichment skipped → ChainlistRPC never called
+        assert "tenderly" in ci.current_rpc.lower()
+        mock_cl_cls.assert_not_called()
+
+    @patch("iwa.core.chain.interface.Web3")
+    def test_enriches_non_tenderly(self, mock_web3):
+        from iwa.core.chain.interface import ChainInterface
+        from iwa.core.chain.models import SupportedChain
+
+        chain = MagicMock(spec=SupportedChain)
+        chain.name = "TestChain"
+        chain.rpcs = ["https://rpc1.example.com"]
+        chain.rpc = "https://rpc1.example.com"
+        chain.chain_id = 100
+
+        with patch("iwa.core.chainlist.ChainlistRPC") as mock_cl_cls:
+            mock_cl = mock_cl_cls.return_value
+            mock_cl.get_validated_rpcs.return_value = [
+                "https://extra1.example.com",
+                "https://extra2.example.com",
+            ]
+            ChainInterface(chain)
+
+        assert len(chain.rpcs) == 3
+        assert "https://extra1.example.com" in chain.rpcs
+        assert "https://extra2.example.com" in chain.rpcs
+        # Original RPC stays first
+        assert chain.rpcs[0] == "https://rpc1.example.com"
+
+    @patch("iwa.core.chain.interface.Web3")
+    def test_survives_fetch_failure(self, mock_web3):
+        from iwa.core.chain.interface import ChainInterface
+        from iwa.core.chain.models import SupportedChain
+
+        chain = MagicMock(spec=SupportedChain)
+        chain.name = "TestChain"
+        chain.rpcs = ["https://rpc1.example.com"]
+        chain.rpc = "https://rpc1.example.com"
+        chain.chain_id = 100
+
+        with patch("iwa.core.chainlist.ChainlistRPC") as mock_cl_cls:
+            mock_cl_cls.side_effect = Exception("network error")
+            ChainInterface(chain)
+
+        # Should still work with original RPCs
+        assert chain.rpcs == ["https://rpc1.example.com"]
+
+    @patch("iwa.core.chain.interface.Web3")
+    def test_respects_max_rpcs(self, mock_web3):
+        from iwa.core.chain.interface import ChainInterface
+        from iwa.core.chain.models import SupportedChain
+
+        chain = MagicMock(spec=SupportedChain)
+        chain.name = "TestChain"
+        chain.rpcs = [f"https://rpc{i}.example.com" for i in range(20)]
+        chain.rpc = "https://rpc0.example.com"
+        chain.chain_id = 100
+
+        with patch("iwa.core.chainlist.ChainlistRPC") as mock_cl_cls:
+            ChainInterface(chain)
+
+        # Already at MAX_RPCS=20, ChainlistRPC should not be called
+        mock_cl_cls.assert_not_called()

tests/test_safe_executor.py

@@ -359,3 +359,281 @@ 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
+
+
+# =============================================================================
+# Test: Fee bumping on base fee errors
+# =============================================================================
+
+
+def test_fee_error_triggers_bump(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """Test that fee errors trigger gas price bump on retry."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        # First attempt fails with fee error, second succeeds
+        mock_safe_tx.execute.side_effect = [
+            ValueError("max fee per gas less than block base fee: maxFeePerGas: 596, baseFee: 681"),
+            b"tx_hash",
+        ]
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
+        # Mock fee calculation
+        mock_chain_interface.web3.eth.get_block.return_value = {"baseFeePerGas": 700}
+        mock_chain_interface.web3.eth.max_priority_fee = 1
+
+        with patch("time.sleep"):
+            success, tx_hash, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        assert success is True
+        assert mock_safe_tx.execute.call_count == 2
+        # Second call should have tx_gas_price (bumped), not eip1559_speed
+        second_call_kwargs = mock_safe_tx.execute.call_args_list[1][1]
+        assert "tx_gas_price" in second_call_kwargs
+
+
+def test_fee_error_classification(executor):
+    """Test classification of fee-related errors."""
+    fee_errors = [
+        "max fee per gas less than block base fee",
+        "transaction underpriced",
+        "maxFeePerGas too low",
+        "fee too low for mempool",
+    ]
+    for error_msg in fee_errors:
+        error = ValueError(error_msg)
+        result = executor._classify_error(error)
+        assert result["is_fee_error"] is True, f"Should detect fee error: {error_msg}"
+
+
+def test_calculate_bumped_gas_price_eip1559(executor, mock_chain_interface):
+    """Test bumped gas price calculation for EIP-1559 chains."""
+    mock_chain_interface.web3.eth.get_block.return_value = {"baseFeePerGas": 1000}
+    mock_chain_interface.web3.eth.max_priority_fee = 10
+
+    # With 1.3x bump factor: base_fee * 1.3 * 1.5 + priority = 1000 * 1.3 * 1.5 + 10 = 1960
+    result = executor._calculate_bumped_gas_price(1.3)
+
+    assert result is not None
+    assert result == int(1000 * 1.3 * 1.5) + 10
+
+
+def test_calculate_bumped_gas_price_legacy(executor, mock_chain_interface):
+    """Test bumped gas price calculation for legacy chains."""
+    mock_chain_interface.web3.eth.get_block.return_value = {}  # No baseFeePerGas
+    mock_chain_interface.web3.eth.gas_price = 2000
+
+    # Legacy: gas_price * bump_factor = 2000 * 1.3 = 2600
+    result = executor._calculate_bumped_gas_price(1.3)
+
+    assert result is not None
+    assert result == int(2000 * 1.3)