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

iwa/core/chain/interface.py

@@ -26,6 +26,11 @@ class ChainInterface:
     DEFAULT_RETRY_DELAY = 1.0  # Base delay between retries (exponential backoff)
     ROTATION_COOLDOWN_SECONDS = 2.0  # Minimum time between RPC rotations
 
+    # Per-error-type backoff durations (seconds) applied to the offending RPC.
+    RATE_LIMIT_BACKOFF = 10.0  # 429 Too Many Requests
+    QUOTA_EXCEEDED_BACKOFF = 300.0  # RPC quota exhausted (resets hourly/daily)
+    CONNECTION_ERROR_BACKOFF = 30.0  # Timeout / connection refused / DNS
+
     chain: SupportedChain
 
     def __init__(self, chain: Union[SupportedChain, str] = None):
@@ -36,10 +41,9 @@ class ChainInterface:
             chain: SupportedChain = getattr(SupportedChains(), chain.lower())
 
         self.chain = chain
-        # Enforce strict 1.0 RPS limit to prevent synchronization issues
-        self._rate_limiter = get_rate_limiter(chain.name, rate=1.0, burst=1)
+        self._rate_limiter = get_rate_limiter(chain.name, rate=5.0, burst=10)
         self._current_rpc_index = 0
-        self._rpc_failure_counts: Dict[int, int] = {}
+        self._rpc_backoff_until: Dict[int, float] = {}  # index -> monotonic expiry
         self._last_rotation_time = 0.0  # Monotonic timestamp of last rotation
 
         if self.chain.rpc and self.chain.rpc.startswith("http://"):
@@ -229,6 +233,34 @@ class ChainInterface:
         ]
         return any(signal in err_text for signal in gas_signals)
 
+    def _is_quota_exceeded_error(self, error: Exception) -> bool:
+        """Check if the RPC's usage quota has been exhausted.
+
+        JSON-RPC code -32001 with messages like "Exceeded the quota usage"
+        indicates the provider's daily/hourly quota is spent.  This is NOT
+        a transient 429 rate-limit; the RPC will reject ALL requests until
+        the quota resets, so it must be backed off for a long period.
+        """
+        err_text = str(error).lower()
+        quota_signals = [
+            "exceeded the quota",
+            "exceeded quota",
+            "quota usage",
+            "quota exceeded",
+            "allowance exceeded",
+        ]
+        return any(signal in err_text for signal in quota_signals)
+
+    # -- Per-RPC health tracking ------------------------------------------
+
+    def _mark_rpc_backoff(self, index: int, seconds: float) -> None:
+        """Mark an RPC as temporarily unavailable for *seconds*."""
+        self._rpc_backoff_until[index] = time.monotonic() + seconds
+
+    def _is_rpc_healthy(self, index: int) -> bool:
+        """Return True if the RPC at *index* is not in backoff."""
+        return time.monotonic() >= self._rpc_backoff_until.get(index, 0.0)
+
     def _handle_rpc_error(self, error: Exception) -> Dict[str, Union[bool, int]]:
         """Handle RPC errors with smart rotation and retry logic."""
         result: Dict[str, Union[bool, int]] = {
@@ -237,6 +269,7 @@ class ChainInterface:
             "is_server_error": self._is_server_error(error),
             "is_gas_error": self._is_gas_error(error),
             "is_tenderly_quota": self._is_tenderly_quota_exceeded(error),
+            "is_quota_exceeded": self._is_quota_exceeded_error(error),
             "rotated": False,
             "should_retry": False,
         }
@@ -251,19 +284,33 @@ class ChainInterface:
                 "Run 'uv run -m iwa.tools.reset_tenderly' to reset."
             )
 
-        self._rpc_failure_counts[self._current_rpc_index] = (
-            self._rpc_failure_counts.get(self._current_rpc_index, 0) + 1
+        # Determine if we need to rotate and what backoff to apply.
+        should_rotate = (
+            result["is_rate_limit"]
+            or result["is_connection_error"]
+            or result["is_quota_exceeded"]
         )
 
-        should_rotate = result["is_rate_limit"] or result["is_connection_error"]
-
         if should_rotate:
-            error_type = "rate limit" if result["is_rate_limit"] else "connection"
-            # Extract the original URL from the error message for clarity
-            error_msg = str(error)
+            failed_index = self._current_rpc_index
+
+            # Apply per-RPC backoff so smart rotation skips this RPC.
+            if result["is_quota_exceeded"]:
+                error_type = "quota exceeded"
+                self._mark_rpc_backoff(failed_index, self.QUOTA_EXCEEDED_BACKOFF)
+            elif result["is_rate_limit"]:
+                error_type = "rate limit"
+                self._mark_rpc_backoff(failed_index, self.RATE_LIMIT_BACKOFF)
+                # Brief global backoff so other threads don't immediately flood
+                # the same (now backed-off) RPC before rotation takes effect.
+                self._rate_limiter.trigger_backoff(seconds=2.0)
+            else:
+                error_type = "connection"
+                self._mark_rpc_backoff(failed_index, self.CONNECTION_ERROR_BACKOFF)
+
             logger.warning(
                 f"RPC {error_type} error on {self.chain.name} "
-                f"(current RPC #{self._current_rpc_index}): {error_msg}"
+                f"(RPC #{failed_index}): {error}"
             )
 
             if self.rotate_rpc():
@@ -271,14 +318,11 @@ class ChainInterface:
                 result["should_retry"] = True
                 logger.info(f"Rotated to RPC #{self._current_rpc_index} for {self.chain.name}")
             else:
-                if result["is_rate_limit"]:
-                    # Rotation was skipped (cooldown or single RPC) - still allow retry with current RPC
-                    # We don't trigger backoff here because that would block ALL threads.
-                    # Instead, we let the individual thread retry (which has its own exponential backoff).
-                    result["should_retry"] = True
-                    logger.info(
-                        f"RPC rotation skipped, retrying with current RPC #{self._current_rpc_index}"
-                    )
+                # Rotation skipped (cooldown or single RPC) - still allow retry
+                result["should_retry"] = True
+                logger.info(
+                    f"RPC rotation skipped, retrying with current RPC #{self._current_rpc_index}"
+                )
 
         elif result["is_server_error"]:
             logger.warning(f"Server error on {self.chain.name}: {error}")
@@ -291,30 +335,40 @@ class ChainInterface:
         return result
 
     def rotate_rpc(self) -> bool:
-        """Rotate to the next available RPC."""
+        """Rotate to the next healthy RPC, skipping those in backoff."""
         with self._rotation_lock:
-            if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
+            n = len(self.chain.rpcs) if self.chain.rpcs else 0
+            if n <= 1:
                 return False
 
             # Cooldown: prevent cascade rotations from in-flight requests
             now = time.monotonic()
-            elapsed = now - self._last_rotation_time
-            if elapsed < self.ROTATION_COOLDOWN_SECONDS:
-                logger.debug(
-                    f"RPC rotation skipped for {self.chain.name} (cooldown active, "
-                    f"{self.ROTATION_COOLDOWN_SECONDS - elapsed:.1f}s remaining)"
-                )
+            if now - self._last_rotation_time < self.ROTATION_COOLDOWN_SECONDS:
                 return False
 
-            # Simple Round Robin rotation
-            self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
-            # Internal call to _init_web3 already expects to be under lock if called from here,
-            # but _init_web3 itself doesn't have a lock. Let's make it consistent.
+            # Try each other RPC in round-robin order, preferring healthy ones.
+            best: Optional[int] = None
+            for offset in range(1, n):
+                candidate = (self._current_rpc_index + offset) % n
+                if self._is_rpc_healthy(candidate):
+                    best = candidate
+                    break
+
+            if best is None:
+                # All RPCs are in backoff — pick the one whose backoff expires soonest.
+                best = min(
+                    (i for i in range(n) if i != self._current_rpc_index),
+                    key=lambda i: self._rpc_backoff_until.get(i, 0.0),
+                )
+
+            self._current_rpc_index = best
             self._init_web3_under_lock()
             self._last_rotation_time = now
 
+            healthy_tag = "" if self._is_rpc_healthy(best) else " (still in backoff)"
             logger.info(
-                f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
+                f"Rotated RPC for {self.chain.name} to index {best}: "
+                f"{self.chain.rpcs[best]}{healthy_tag}"
             )
             return True
 
@@ -583,6 +637,6 @@ class ChainInterface:
         return self.chain.contracts.get(contract_name)
 
     def reset_rpc_failure_counts(self):
-        """Reset RPC failure tracking. Call periodically to allow retrying failed RPCs."""
-        self._rpc_failure_counts.clear()
-        logger.debug("Reset RPC failure counts")
+        """Reset RPC backoff tracking. Call periodically to allow retrying backed-off RPCs."""
+        self._rpc_backoff_until.clear()
+        logger.debug("Reset RPC backoff tracking")

iwa/core/chain/rate_limiter.py

@@ -128,9 +128,22 @@ class RateLimitedEth:
     # Helper sets for efficient lookup
     RPC_METHODS = READ_METHODS | WRITE_METHODS
 
-    DEFAULT_READ_RETRIES = 3
+    DEFAULT_READ_RETRIES = 1  # Keep low; ChainInterface.with_retry handles cross-RPC retries
     DEFAULT_READ_RETRY_DELAY = 0.5
 
+    # Only retry errors that are clearly transient network issues.
+    # Rate-limit / quota / server errors propagate up to with_retry for rotation.
+    TRANSIENT_SIGNALS = (
+        "timeout",
+        "timed out",
+        "connection reset",
+        "connection refused",
+        "connection aborted",
+        "broken pipe",
+        "eof",
+        "remote end closed",
+    )
+
     def __init__(self, web3_eth, rate_limiter: RPCRateLimiter, chain_interface: "ChainInterface"):
         """Initialize RateLimitedEth wrapper."""
         object.__setattr__(self, "_eth", web3_eth)
@@ -187,20 +200,36 @@ class RateLimitedEth:
         return wrapper
 
     def _execute_with_retry(self, method, method_name, *args, **kwargs):
-        """Execute read operation with retry logic."""
+        """Execute a read operation with limited retry for transient errors.
+
+        Only connection-level failures (timeout, reset, broken pipe) are
+        retried here.  Rate-limit, quota, and server errors propagate up
+        to ``ChainInterface.with_retry`` which handles RPC rotation.
+        This avoids the double-retry amplification that previously caused
+        up to 4x7 = 28 RPC requests per logical call.
+        """
         for attempt in range(self.DEFAULT_READ_RETRIES + 1):
             try:
                 return method(*args, **kwargs)
             except Exception as e:
-                # Use chain interface to handle error (logging, rotation, etc.)
-                result = self._chain_interface._handle_rpc_error(e)
+                if attempt >= self.DEFAULT_READ_RETRIES:
+                    raise
 
-                if not result["should_retry"] or attempt >= self.DEFAULT_READ_RETRIES:
+                # Only retry clearly transient network errors.
+                err_text = str(e).lower()
+                if not any(signal in err_text for signal in self.TRANSIENT_SIGNALS):
                     raise
 
+                # Re-acquire a rate-limiter token before retrying.
+                if not self._rate_limiter.acquire(timeout=30.0):
+                    raise TimeoutError(
+                        f"Rate limit timeout for retry of {method_name}"
+                    ) from e
+
                 delay = self.DEFAULT_READ_RETRY_DELAY * (2**attempt)
                 logger.debug(
-                    f"{method_name} attempt {attempt + 1} failed, retrying in {delay:.1f}s..."
+                    f"{method_name} attempt {attempt + 1} failed (transient), "
+                    f"retrying in {delay:.1f}s..."
                 )
                 time.sleep(delay)
 

{iwa-0.0.59.dist-info → iwa-0.0.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.59
+Version: 0.0.60
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown

{iwa-0.0.59.dist-info → iwa-0.0.60.dist-info}/RECORD

@@ -23,10 +23,10 @@ iwa/core/utils.py,sha256=FTYpIdQ1wnugD4lYU4TQ7d7_TlDs4CTUIhEpHGEJph4,4281
 iwa/core/wallet.py,sha256=xSGFOK5Wzh-ctLGhBMK1BySlXN0Ircpztyk1an21QiQ,13129
 iwa/core/chain/__init__.py,sha256=XJMmn0ed-_aVkY2iEMKpuTxPgIKBd41dexSVmEZTa-o,1604
 iwa/core/chain/errors.py,sha256=9SEbhxZ-qASPkzt-DoI51qq0GRJVqRgqgL720gO7a64,1275
-iwa/core/chain/interface.py,sha256=FNb_M1Hl1FlgyC3FUPKH91RW7tF-wKJXQP4iOI14vGg,23798
+iwa/core/chain/interface.py,sha256=ww779Wek8qeIxu5t0v3hcmwXq7dMaxp0TjpW4Eikg8Y,25924
 iwa/core/chain/manager.py,sha256=cFEzh6pK5OyVhjhpeMAqhc9RnRDQR1DjIGiGKp-FXBI,1159
 iwa/core/chain/models.py,sha256=WUhAighMKcFdbAUkPU_3dkGbWyAUpRJqXMHLcWFC1xg,5261
-iwa/core/chain/rate_limiter.py,sha256=6XnaB6i3Tvf-6YD4L-YBeJnKjAIuAxBGDvTmm1dQDTM,7924
+iwa/core/chain/rate_limiter.py,sha256=Ps1MrR4HHtylxgUAawe6DoC9tuqKagjQdKulqcJD2gs,9093
 iwa/core/contracts/__init__.py,sha256=P5GFY_pnuI02teqVY2U0t98bn1_SSPAbcAzRMpCdTi4,34
 iwa/core/contracts/cache.py,sha256=vN7ArNhNsSDr1rYHDMWsMm6VbSszBt4Xej9MeI-rkgc,4452
 iwa/core/contracts/contract.py,sha256=TLZGF7BtMl2fr92B80Gp3ttnP4hJsdAG-raaFZiNLO8,13255
@@ -166,7 +166,7 @@ iwa/web/tests/test_web_endpoints.py,sha256=vA25YghHNB23sbmhD4ciesn_f_okSq0tjlkrS
 iwa/web/tests/test_web_olas.py,sha256=0CVSsrncOeJ3x0ECV7mVLQV_CXZRrOqGiVjgLIi6hZ8,16308
 iwa/web/tests/test_web_swap.py,sha256=7A4gBJFL01kIXPtW1E1J17SCsVc_0DmUn-R8kKrnnVA,2974
 iwa/web/tests/test_web_swap_coverage.py,sha256=zGNrzlhZ_vWDCvWmLcoUwFgqxnrp_ACbo49AtWBS_Kw,5584
-iwa-0.0.59.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.0.60.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
 tests/legacy_cow.py,sha256=oOkZvIxL70ReEoD9oHQbOD5GpjIr6AGNHcOCgfPlerU,8389
 tests/legacy_safe.py,sha256=AssM2g13E74dNGODu_H0Q0y412lgqsrYnEzI97nm_Ts,2972
 tests/legacy_transaction_retry_logic.py,sha256=D9RqZ7DBu61Xr2djBAodU2p9UE939LL-DnQXswX5iQk,1497
@@ -176,7 +176,7 @@ tests/legacy_web.py,sha256=q2ERIriaDHT3Q8axG2N3ucO7f2VSvV_WkuPR00DVko4,8577
 tests/test_account_service.py,sha256=g_AIVT2jhlvUtbFTaCd-d15x4CmXJQaV66tlAgnaXwY,3745
 tests/test_balance_service.py,sha256=wcuCOVszxPy8nPkldAVcEiygcOK3BuQt797fqAJvbp4,4979
 tests/test_chain.py,sha256=VZoidSojWyt1y4mQdZdoZsjuuDZjLC6neTC-2SF_Q7I,13957
-tests/test_chain_interface.py,sha256=Wu0q0sREtmYBp7YvWrBIrrSTtqeQj18oJp2VmMUEMec,8312
+tests/test_chain_interface.py,sha256=bgqGM8wJGZjc-BOX6i0K4sh06KCJl-6UAvrwl8x24lA,8324
 tests/test_chain_interface_coverage.py,sha256=fvrVvw8-DMwdsSFKQHUhpbfutrVRxnnTc-tjB7Bb-jo,3327
 tests/test_cli.py,sha256=Pl4RC2xp1omiJUnL3Dza6pCmIoO29LJ0vGw33_ZpT5c,3980
 tests/test_contract.py,sha256=tApHAxsfKGawYJWA9PhTNrOZUE0VVAq79ruIe3KxeWY,14412
@@ -194,11 +194,11 @@ tests/test_models.py,sha256=1bEfPiDVgEdtwFEzwecSPAHjCF8kjOPSMeQExJ7eCJ4,7107
 tests/test_monitor.py,sha256=dRVS6EkTwfvGEOg7t0dVhs6M3oEZExBH7iBZe6hmk4M,7261
 tests/test_multisend.py,sha256=IvXpwnC5xSDRCyCDGcMdO3L-eQegvdjAzHZB0FoVFUI,2685
 tests/test_plugin_service.py,sha256=ZEe37kV_sv4Eb04032O1hZIoo9yf5gJo83ks7Grzrng,3767
-tests/test_rate_limiter.py,sha256=gC-mVsTCqGbBoUxAllY_WS9kl12rBHQv7MNr1zdUdGQ,7334
-tests/test_rate_limiter_retry.py,sha256=gU4AJk1s39HvdcbGeIoIrr1M7p6WMba_n2y8eFNSXc8,4261
+tests/test_rate_limiter.py,sha256=XDN22HWs85OicBpQ9zgHRnoJ1VMola_AOkobqp83dfs,7444
+tests/test_rate_limiter_retry.py,sha256=Yq7Ik2r8VIYgPdlSN2tYbdA0ngrB37ZPimfkZkh9Cvk,4568
 tests/test_reset_tenderly.py,sha256=GVoqbDT3n4_GnlKF5Lx-8ew15jT8I2hIPdTulQDb6dI,7215
 tests/test_rpc_efficiency.py,sha256=mNuCoa5r6lSEyTqcRX98oz-huoKMTUlKM2UcOHlTQ6M,3745
-tests/test_rpc_rate_limit.py,sha256=Eo-Nr_7p8jERtouCtKuEmcSzACeiVUb33kt7BeTo4uA,1011
+tests/test_rpc_rate_limit.py,sha256=3P_Nd9voFmz-4r_Et-vw8W-Esbq5elSYmRBSOtJGx1Y,1014
 tests/test_rpc_rotation.py,sha256=a1cFKsf0fo-73_MSDnTuU6Zpv7bJHjrCVu3ANe8PXDU,12541
 tests/test_rpc_view.py,sha256=sgZ53KEHl8VGb7WKYa0VI7Cdxbf8JH1SdroHYbWHjfQ,2031
 tests/test_safe_coverage.py,sha256=KBxKz64XkK8CgN0N0LTNVKakf8Wg8EpghcBlLmDFmLs,6119
@@ -222,8 +222,8 @@ tests/test_utils.py,sha256=vkP49rYNI8BRzLpWR3WnKdDr8upeZjZcs7Rx0pjbQMo,1292
 tests/test_workers.py,sha256=MInwdkFY5LdmFB3o1odIaSD7AQZb3263hNafO1De5PE,2793
 tools/create_and_stake_service.py,sha256=1xwy_bJQI1j9yIQ968Oc9Db_F6mk1659LuuZntTASDE,3742
 tools/verify_drain.py,sha256=PkMjblyOOAuQge88FwfEzRtCYeEtJxXhPBmtQYCoQ-8,6743
-iwa-0.0.59.dist-info/METADATA,sha256=FZrh67solKvQcjzWzdns2HPQGMwPZs0B6_Z2rK7hLJA,7337
-iwa-0.0.59.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-iwa-0.0.59.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.0.59.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.0.59.dist-info/RECORD,,
+iwa-0.0.60.dist-info/METADATA,sha256=BpkWW6DmPQhaX7fFo7LtVfNYg3thQWSMiMmR_yGApCc,7337
+iwa-0.0.60.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iwa-0.0.60.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.0.60.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.0.60.dist-info/RECORD,,

tests/test_chain_interface.py

@@ -201,10 +201,10 @@ def test_is_tenderly_property():
 
 
 def test_reset_rpc_failure_counts(mock_chain_interface):
-    """Test resetting failure counts."""
+    """Test resetting backoff tracking."""
     interface, _ = mock_chain_interface
-    interface._rpc_failure_counts = {0: 5, 1: 3}
+    interface._rpc_backoff_until = {0: 99999.0, 1: 99999.0}
 
     interface.reset_rpc_failure_counts()
 
-    assert interface._rpc_failure_counts == {}
+    assert interface._rpc_backoff_until == {}

tests/test_rate_limiter.py

@@ -146,7 +146,7 @@ class TestRateLimitRotationInterplay:
     """Test interaction between rate limiting and RPC rotation."""
 
     def test_rate_limit_triggers_rotation_first(self):
-        """Test that rate limit error triggers RPC rotation before backoff."""
+        """Test that rate limit error triggers RPC rotation and global backoff."""
         from unittest.mock import MagicMock, PropertyMock
 
         from iwa.core.chain import ChainInterface, SupportedChain
@@ -171,8 +171,10 @@ class TestRateLimitRotationInterplay:
                 assert result["rotated"] is True
                 assert result["should_retry"] is True
                 assert ci._current_rpc_index != original_index
-                # Backoff should NOT be triggered since rotation succeeded
-                assert ci._rate_limiter.get_status()["in_backoff"] is False
+                # Global backoff IS triggered to slow other threads briefly
+                assert ci._rate_limiter.get_status()["in_backoff"] is True
+                # The old RPC should be marked in per-RPC backoff
+                assert not ci._is_rpc_healthy(original_index)
 
     def test_rate_limit_triggers_backoff_when_no_rotation(self):
         """Test that rate limit triggers backoff when no other RPCs available."""
@@ -193,7 +195,7 @@ class TestRateLimitRotationInterplay:
             rate_limit_error = Exception("Error 429: Too Many Requests")
             result = ci._handle_rpc_error(rate_limit_error)
 
-            # Should have triggered retry but NO backoff (skipped for single RPC)
+            # Should have triggered retry and global backoff
             assert result["should_retry"] is True
             assert result["rotated"] is False
-            assert ci._rate_limiter.get_status()["in_backoff"] is False
+            assert ci._rate_limiter.get_status()["in_backoff"] is True

tests/test_rate_limiter_retry.py

@@ -19,28 +19,39 @@ class TestRateLimitedEthRetry:
         chain_interface = MockChainInterface()
         return web3_eth, rate_limiter, chain_interface
 
-    def test_read_method_retries_on_failure(self, mock_deps):
-        """Verify that read methods automatically retry on failure."""
+    def test_read_method_retries_on_transient_failure(self, mock_deps):
+        """Verify that read methods retry on transient (connection) errors."""
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Mock get_balance to fail twice then succeed
+        # Mock get_balance to fail once with transient error then succeed
         web3_eth.get_balance.side_effect = [
-            ValueError("RPC error 1"),
-            ValueError("RPC error 2"),
+            ValueError("connection timeout"),
             100,  # Success
         ]
 
-        # Use patch to speed up sleep
         with patch("time.sleep") as mock_sleep:
             result = eth_wrapper.get_balance("0x123")
 
         assert result == 100
-        assert web3_eth.get_balance.call_count == 3
-        # Should have slept twice
-        assert mock_sleep.call_count == 2
-        # Verify handle_error was called
-        assert chain_interface._handle_rpc_error.call_count == 2
+        # 1 initial + 1 retry = 2 calls (DEFAULT_READ_RETRIES=1)
+        assert web3_eth.get_balance.call_count == 2
+        assert mock_sleep.call_count == 1
+        # RateLimitedEth no longer calls _handle_rpc_error (that's for with_retry)
+        assert chain_interface._handle_rpc_error.call_count == 0
+
+    def test_read_method_raises_non_transient_immediately(self, mock_deps):
+        """Verify non-transient errors (rate limit, quota) propagate immediately."""
+        web3_eth, rate_limiter, chain_interface = mock_deps
+        eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
+
+        web3_eth.get_balance.side_effect = ValueError("429 Too Many Requests")
+
+        with pytest.raises(ValueError, match="429"):
+            eth_wrapper.get_balance("0x123")
+
+        # Only 1 attempt, no retry for non-transient errors
+        assert web3_eth.get_balance.call_count == 1
 
     def test_write_method_no_auto_retry(self, mock_deps):
         """Verify that write methods (send_raw_transaction) DO NOT auto-retry."""
@@ -60,23 +71,21 @@ class TestRateLimitedEthRetry:
         # Should verify it was called only once
         assert web3_eth.send_raw_transaction.call_count == 1
         # Chain interface error handler should NOT be called by the wrapper itself
-        # (It might typically be called by the caller)
         assert chain_interface._handle_rpc_error.call_count == 0
 
     def test_retry_respects_max_attempts(self, mock_deps):
-        """Verify that retry logic respects maximum attempts."""
+        """Verify that retry logic respects maximum attempts for transient errors."""
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Override default retries for quicker test
-        # Use object.__setattr__ because RateLimitedEth overrides __setattr__
+        # Override default retries
         object.__setattr__(eth_wrapper, "DEFAULT_READ_RETRIES", 2)
 
-        # Mock always failing
-        web3_eth.get_code.side_effect = ValueError("Persistently failing")
+        # Mock always failing with transient error
+        web3_eth.get_code.side_effect = ValueError("connection reset by peer")
 
         with patch("time.sleep"):
-            with pytest.raises(ValueError, match="Persistently failing"):
+            with pytest.raises(ValueError, match="connection reset"):
                 eth_wrapper.get_code("0x123")
 
         # Attempts: initial + 2 retries = 3 total calls
@@ -87,17 +96,14 @@ class TestRateLimitedEthRetry:
         web3_eth, rate_limiter, chain_interface = mock_deps
         eth_wrapper = RateLimitedEth(web3_eth, rate_limiter, chain_interface)
 
-        # Mock property access: fail then succeed
-        # Note: PropertyMock is needed if we were mocking a property on the CLASS,
-        # but here we are mocking the instance attribute access which might be a method call or property.
-        # web3.eth.block_number is a property.
-
-        # We need to set side_effect on the PROPERTY of the mock
-        type(web3_eth).block_number = PropertyMock(side_effect=[ValueError("Fail 1"), 12345])
+        # block_number fails once with transient error then succeeds
+        type(web3_eth).block_number = PropertyMock(
+            side_effect=[ValueError("connection timeout"), 12345]
+        )
 
         with patch("time.sleep"):
             val = eth_wrapper.block_number
 
         assert val == 12345
-        # Verify handle_error called
-        assert chain_interface._handle_rpc_error.call_count == 1
+        # _handle_rpc_error is NOT called by RateLimitedEth anymore
+        assert chain_interface._handle_rpc_error.call_count == 0

tests/test_rpc_rate_limit.py

@@ -16,7 +16,7 @@ def clean_rate_limiters():
 
 
 def test_chain_interface_initializes_strict_limiter(clean_rate_limiters):
-    """Verify ChainInterface initializes with rate=1.0 and burst=1."""
+    """Verify ChainInterface initializes with rate=5.0 and burst=10."""
     # Create a dummy chain
     chain = MagicMock(spec=SupportedChain)
     chain.name = "TestSlowChain"
@@ -30,5 +30,5 @@ def test_chain_interface_initializes_strict_limiter(clean_rate_limiters):
     limiter = ci._rate_limiter
 
     # Assert correct configuration
-    assert limiter.rate == 1.0, f"Expected rate 1.0, got {limiter.rate}"
-    assert limiter.burst == 1, f"Expected burst 1, got {limiter.burst}"
+    assert limiter.rate == 5.0, f"Expected rate 5.0, got {limiter.rate}"
+    assert limiter.burst == 10, f"Expected burst 10, got {limiter.burst}"