iwa 0.0.66__py3-none-any.whl → 0.1.0__py3-none-any.whl

iwa/core/chain/interface.py

@@ -228,6 +228,7 @@ class ChainInterface:
             "connect timeout",
             "remote end closed",
             "broken pipe",
+            # Note: "too many open files" handled separately by _is_fd_exhaustion_error
         ]
         return any(signal in err_text for signal in connection_signals)
 
@@ -254,6 +255,21 @@ class ChainInterface:
         ]
         return any(signal in err_text for signal in server_error_signals)
 
+    def _is_fd_exhaustion_error(self, error: Exception) -> bool:
+        """Check if error is due to file descriptor exhaustion (OSError 24).
+
+        When FDs are exhausted, rotating RPCs makes things WORSE because it
+        creates more connections. Instead, we need to pause and let existing
+        connections drain before retrying.
+        """
+        err_text = str(error).lower()
+        fd_signals = [
+            "too many open files",
+            "oserror(24",
+            "errno 24",
+        ]
+        return any(signal in err_text for signal in fd_signals)
+
     def _is_gas_error(self, error: Exception) -> bool:
         """Check if error is related to gas limits or fees."""
         err_text = str(error).lower()
@@ -326,6 +342,9 @@ class ChainInterface:
         """Return True if the RPC at *index* is not in backoff."""
         return time.monotonic() >= self._rpc_backoff_until.get(index, 0.0)
 
+    # FD exhaustion backoff: wait for connections to drain
+    FD_EXHAUSTION_BACKOFF = 60.0  # Long pause to let FDs drain
+
     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]] = {
@@ -335,10 +354,26 @@ class ChainInterface:
             "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),
+            "is_fd_exhaustion": self._is_fd_exhaustion_error(error),
             "rotated": False,
             "should_retry": False,
         }
 
+        # FD exhaustion: DO NOT rotate (creates more connections), just pause
+        if result["is_fd_exhaustion"]:
+            logger.error(
+                f"[{self.chain.name}] FD EXHAUSTION detected (too many open files). "
+                f"Pausing all RPCs for {int(self.FD_EXHAUSTION_BACKOFF)}s to drain connections. "
+                f"NO rotation to avoid creating more connections."
+            )
+            # Mark ALL RPCs as in backoff to prevent any activity
+            for i in range(len(self.chain.rpcs) if self.chain.rpcs else 0):
+                self._mark_rpc_backoff(i, self.FD_EXHAUSTION_BACKOFF)
+            # Trigger global rate limit backoff
+            self._rate_limiter.trigger_backoff(seconds=self.FD_EXHAUSTION_BACKOFF)
+            result["should_retry"] = True  # Retry after backoff
+            return result
+
         if result["is_tenderly_quota"]:
             logger.error(
                 "TENDERLY QUOTA EXCEEDED! The virtual network has reached its limit. "

iwa/core/services/safe.py

@@ -1,6 +1,6 @@
 """Safe service module."""
 
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, List, Optional, Tuple
 
 from loguru import logger
 from safe_eth.eth import EthereumClient
@@ -35,7 +35,6 @@ class SafeService:
         """Initialize SafeService."""
         self.key_storage = key_storage
         self.account_service = account_service
-        self._client_cache: Dict[str, EthereumClient] = {}
 
     def create_safe(
         self,
@@ -100,15 +99,14 @@ class SafeService:
 
     def _get_ethereum_client(self, chain_name: str) -> EthereumClient:
         from iwa.core.chain import ChainInterfaces
+        from iwa.plugins.gnosis.safe import get_ethereum_client
 
         # Use ChainInterface which has proper RPC rotation and parsing
         chain_interface = ChainInterfaces().get(chain_name)
         rpc_url = chain_interface.current_rpc
 
-        if rpc_url not in self._client_cache:
-            self._client_cache[rpc_url] = EthereumClient(rpc_url)
-
-        return self._client_cache[rpc_url]
+        # Use shared cache to prevent FD exhaustion
+        return get_ethereum_client(rpc_url)
 
     def _deploy_safe_contract(
         self,
@@ -256,11 +254,8 @@ class SafeService:
                 continue
 
             for chain in account.chains:
-                from iwa.core.chain import ChainInterfaces
-
-                # Use ChainInterface which has proper RPC rotation and parsing
-                chain_interface = ChainInterfaces().get(chain)
-                ethereum_client = EthereumClient(chain_interface.current_rpc)
+                # Reuse cached EthereumClient to prevent FD exhaustion
+                ethereum_client = self._get_ethereum_client(chain)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 
@@ -375,7 +370,9 @@ class SafeService:
         if not safe_account or not isinstance(safe_account, StoredSafeAccount):
             raise ValueError(f"Safe account '{safe_address_or_tag}' not found.")
 
-        safe = SafeMultisig(safe_account, chain_name)
+        # Reuse cached EthereumClient to prevent FD exhaustion
+        ethereum_client = self._get_ethereum_client(chain_name)
+        safe = SafeMultisig(safe_account, chain_name, ethereum_client=ethereum_client)
         safe_tx = safe.build_tx(
             to=to,
             value=value,

iwa/core/services/safe_executor.py

@@ -1,10 +1,10 @@
 """Safe transaction executor with retry logic and gas handling."""
 
 import time
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, List, Optional, Tuple
 
 from loguru import logger
-from safe_eth.eth import EthereumClient, TxSpeed
+from safe_eth.eth import TxSpeed
 from safe_eth.safe import Safe
 from safe_eth.safe.safe_tx import SafeTx
 
@@ -56,7 +56,6 @@ class SafeTransactionExecutor:
         config = Config().core
         self.max_retries = max_retries or config.safe_tx_max_retries
         self.gas_buffer = gas_buffer or config.safe_tx_gas_buffer
-        self._client_cache: Dict[str, EthereumClient] = {}
 
     def execute_with_retry(
         self,
@@ -64,7 +63,7 @@ class SafeTransactionExecutor:
         safe_tx: SafeTx,
         signer_keys: List[str],
         operation_name: str = "safe_tx",
-    ) -> Tuple[bool, str, Optional[Dict]]:
+    ) -> Tuple[bool, str, Optional[dict]]:
         """Execute SafeTx with full retry mechanism.
 
         Args:
@@ -303,10 +302,11 @@ class SafeTransactionExecutor:
 
     def _recreate_safe_client(self, safe_address: str) -> Safe:
         """Recreate Safe with current (possibly rotated) RPC."""
+        from iwa.plugins.gnosis.safe import get_ethereum_client
+
         rpc_url = self.chain_interface.current_rpc
-        if rpc_url not in self._client_cache:
-            self._client_cache[rpc_url] = EthereumClient(rpc_url)
-        ethereum_client = self._client_cache[rpc_url]
+        # Use shared cache to prevent FD exhaustion
+        ethereum_client = get_ethereum_client(rpc_url)
         return Safe(safe_address, ethereum_client)
 
     def _is_nonce_error(self, error: Exception) -> bool:

iwa/plugins/gnosis/cow/swap.py

@@ -29,6 +29,20 @@ warnings.filterwarnings(
 
 logger = configure_logger()
 
+# Module-level session for connection pooling (avoids FD leak)
+_session: requests.Session | None = None
+
+
+def _get_session() -> requests.Session:
+    """Get or create the module-level HTTP session."""
+    global _session
+    if _session is None:
+        from iwa.core.http import create_retry_session
+
+        _session = create_retry_session()
+    return _session
+
+
 if TYPE_CHECKING:
     from cowdao_cowpy.common.chains import Chain
     from cowdao_cowpy.cow.swap import CompletedOrder
@@ -97,13 +111,14 @@ class CowSwap:
         logger.info(f"Checking order status for UID: {order.uid}")
 
         sleep_between_retries = 15
+        session = _get_session()
+        loop = asyncio.get_event_loop()
 
         while True:
             try:
-                # Use a thread executor for blocking requests.get
-                loop = asyncio.get_event_loop()
+                # Use a thread executor for blocking HTTP request
                 response = await loop.run_in_executor(
-                    None, lambda: requests.get(order.url, timeout=60)
+                    None, lambda s=session: s.get(order.url, timeout=60)
                 )
             except Exception as e:
                 logger.warning(f"Error checking order status: {e}")

iwa/plugins/gnosis/safe.py

@@ -1,6 +1,6 @@
 """Gnosis Safe interaction."""
 
-from typing import Callable, Optional
+from typing import Callable, Dict, Optional
 
 from safe_eth.eth import EthereumClient
 from safe_eth.eth.constants import NULL_ADDRESS
@@ -12,6 +12,46 @@ from iwa.core.utils import configure_logger
 
 logger = configure_logger()
 
+# Shared EthereumClient cache to prevent FD leaks
+# Limited to MAX_CACHED_CLIENTS to avoid unbounded growth during RPC rotations
+_ethereum_client_cache: Dict[str, EthereumClient] = {}
+MAX_CACHED_CLIENTS = 3  # Keep only recent clients to limit FD usage
+
+
+def _cleanup_old_clients(keep_url: str) -> None:
+    """Remove oldest cached clients to stay under limit."""
+    global _ethereum_client_cache
+    while len(_ethereum_client_cache) >= MAX_CACHED_CLIENTS:
+        # Remove oldest entry (first key in dict, preserves insertion order in Python 3.7+)
+        for old_url in list(_ethereum_client_cache.keys()):
+            if old_url != keep_url:
+                old_client = _ethereum_client_cache.pop(old_url)
+                # Try to close any underlying HTTP session
+                if hasattr(old_client, "w3") and hasattr(old_client.w3, "provider"):
+                    provider = old_client.w3.provider
+                    if hasattr(provider, "_request_kwargs"):
+                        session = provider._request_kwargs.get("session")
+                        if session and hasattr(session, "close"):
+                            try:
+                                session.close()
+                            except Exception:
+                                pass
+                logger.debug(f"Evicted EthereumClient for {old_url} from cache")
+                break
+
+
+def get_ethereum_client(rpc_url: str) -> EthereumClient:
+    """Get a cached EthereumClient for the given RPC URL.
+
+    Reuses existing clients to prevent file descriptor exhaustion.
+    Limited to MAX_CACHED_CLIENTS to prevent unbounded cache growth
+    during RPC rotations.
+    """
+    if rpc_url not in _ethereum_client_cache:
+        _cleanup_old_clients(rpc_url)
+        _ethereum_client_cache[rpc_url] = EthereumClient(rpc_url)
+    return _ethereum_client_cache[rpc_url]
+
 
 class SafeMultisig:
     """Class to interact with Gnosis Safe multisig wallets.
@@ -20,17 +60,32 @@ class SafeMultisig:
     checking owners, thresholds, and building/sending multi-signature transactions.
     """
 
-    def __init__(self, safe_account: StoredSafeAccount, chain_name: str):
-        """Initialize the SafeMultisig instance."""
+    def __init__(
+        self,
+        safe_account: StoredSafeAccount,
+        chain_name: str,
+        ethereum_client: Optional[EthereumClient] = None,
+    ):
+        """Initialize the SafeMultisig instance.
+
+        Args:
+            safe_account: The Safe account to interact with.
+            chain_name: The chain name (e.g., 'gnosis').
+            ethereum_client: Optional pre-existing EthereumClient.
+                If not provided, uses a shared cached client.
+
+        """
         # Normalize chain comparison to be case-insensitive
         normalized_chains = [c.lower() for c in safe_account.chains]
         if chain_name.lower() not in normalized_chains:
             raise ValueError(f"Safe account is not deployed on chain: {chain_name}")
 
-        from iwa.core.chain import ChainInterfaces
+        if ethereum_client is None:
+            from iwa.core.chain import ChainInterfaces
+
+            chain_interface = ChainInterfaces().get(chain_name.lower())
+            ethereum_client = get_ethereum_client(chain_interface.current_rpc)
 
-        chain_interface = ChainInterfaces().get(chain_name.lower())
-        ethereum_client = EthereumClient(chain_interface.current_rpc)
         self.multisig = Safe(safe_account.address, ethereum_client)
         self.ethereum_client = ethereum_client
 

iwa/plugins/gnosis/tests/test_cow.py

@@ -175,19 +175,18 @@ async def test_check_cowswap_order_success(cowswap):
     mock_order = MagicMock()
     mock_order.url = "http://api/order"
 
-    with patch("requests.get") as mock_get:
-        mock_get.return_value.status_code = 200
-        mock_get.return_value.json.return_value = {
-            "status": "fulfilled",
-            "executedSellAmount": "100",
-            "executedBuyAmount": "90",
-        }
-
-        # Need to mock loop.run_in_executor since check_cowswap_order uses it
-        # Or just let it run if requests.get is mocked?
-        # check_cowswap_order calls loop.run_in_executor(None, lambda: requests.get(...))
-        # This will run the lambda in a thread. The mock should work.
-
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {
+        "status": "fulfilled",
+        "executedSellAmount": "100",
+        "executedBuyAmount": "90",
+    }
+
+    mock_session = MagicMock()
+    mock_session.get.return_value = mock_response
+
+    with patch("iwa.plugins.gnosis.cow.swap._get_session", return_value=mock_session):
         result = await cowswap.check_cowswap_order(mock_order)
 
         assert result == {
@@ -203,10 +202,14 @@ async def test_check_cowswap_order_expired(cowswap):
     mock_order = MagicMock()
     mock_order.url = "http://api/order"
 
-    with patch("requests.get") as mock_get:
-        mock_get.return_value.status_code = 200
-        mock_get.return_value.json.return_value = {"status": "expired"}
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"status": "expired"}
+
+    mock_session = MagicMock()
+    mock_session.get.return_value = mock_response
 
+    with patch("iwa.plugins.gnosis.cow.swap._get_session", return_value=mock_session):
         result = await cowswap.check_cowswap_order(mock_order)
         assert result is None
 
@@ -217,20 +220,20 @@ async def test_check_cowswap_order_timeout(cowswap):
     mock_order = MagicMock()
     mock_order.url = "http://api/order"
 
-    with patch("requests.get") as mock_get:
-        mock_get.return_value.status_code = 200
-        # Order is always open
-        mock_get.return_value.json.return_value = {
-            "status": "open",
-            "executedSellAmount": "0",
-            "validTo": 1000,
-        }
-
-        # Mock time to start at 900 and then jump to 1100 to trigger timeout
-        with patch("time.time") as mock_time:
-            mock_time.side_effect = [900, 1100]
-            # Speed up retry sleep (asyncio.sleep)
-            with patch("asyncio.sleep", new_callable=AsyncMock):
-                result = await cowswap.check_cowswap_order(mock_order)
-                assert result is None
-                assert mock_time.call_count >= 2
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    # Order is always open, validTo = 1000
+    mock_response.json.return_value = {
+        "status": "open",
+        "executedSellAmount": "0",
+        "validTo": 1000,
+    }
+
+    mock_session = MagicMock()
+    mock_session.get.return_value = mock_response
+
+    with patch("iwa.plugins.gnosis.cow.swap._get_session", return_value=mock_session):
+        # Mock time to return >1060 (validTo + 60) to trigger timeout on first check
+        with patch("iwa.plugins.gnosis.cow.swap.time.time", return_value=1100):
+            result = await cowswap.check_cowswap_order(mock_order)
+            assert result is None

iwa/plugins/gnosis/tests/test_safe.py

@@ -5,7 +5,12 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from iwa.core.models import StoredSafeAccount
-from iwa.plugins.gnosis.safe import SafeMultisig
+from iwa.plugins.gnosis.safe import (
+    MAX_CACHED_CLIENTS,
+    SafeMultisig,
+    _ethereum_client_cache,
+    get_ethereum_client,
+)
 
 
 @pytest.fixture
@@ -100,3 +105,83 @@ def test_send_tx(safe_account, mock_settings, mock_safe_eth):
     assert tx_hash == "0xHash"
 
     callback.assert_called_with("0xSafeTx")
+
+
+class TestEthereumClientCache:
+    """Tests for EthereumClient caching to prevent FD exhaustion."""
+
+    def setup_method(self):
+        """Clear cache before each test."""
+        _ethereum_client_cache.clear()
+
+    def test_cache_reuses_client(self):
+        """Test that the same RPC URL returns the same cached client."""
+        with patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client_cls:
+            mock_client_cls.return_value = MagicMock()
+
+            client1 = get_ethereum_client("https://rpc1.example.com")
+            client2 = get_ethereum_client("https://rpc1.example.com")
+
+            assert client1 is client2
+            # Should only create one instance
+            assert mock_client_cls.call_count == 1
+
+    def test_cache_different_urls(self):
+        """Test that different URLs create different clients."""
+        with patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client_cls:
+            mock_client_cls.side_effect = lambda url: MagicMock(url=url)
+
+            client1 = get_ethereum_client("https://rpc1.example.com")
+            client2 = get_ethereum_client("https://rpc2.example.com")
+
+            assert client1 is not client2
+            assert mock_client_cls.call_count == 2
+
+    def test_cache_limit_enforced(self):
+        """Test that cache is limited to MAX_CACHED_CLIENTS."""
+        with patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client_cls:
+            # Create mock clients with closeable sessions
+            def create_mock_client(url):
+                client = MagicMock(url=url)
+                client.w3 = MagicMock()
+                client.w3.provider = MagicMock()
+                client.w3.provider._request_kwargs = {"session": MagicMock()}
+                return client
+
+            mock_client_cls.side_effect = create_mock_client
+
+            # Create more clients than the limit
+            urls = [f"https://rpc{i}.example.com" for i in range(MAX_CACHED_CLIENTS + 2)]
+            for url in urls:
+                get_ethereum_client(url)
+
+            # Cache should not exceed limit
+            assert len(_ethereum_client_cache) <= MAX_CACHED_CLIENTS
+
+    def test_cache_evicts_oldest(self):
+        """Test that oldest entries are evicted when limit is reached."""
+        with patch("iwa.plugins.gnosis.safe.EthereumClient") as mock_client_cls:
+
+            def create_mock_client(url):
+                client = MagicMock(url=url)
+                client.w3 = MagicMock()
+                client.w3.provider = MagicMock()
+                client.w3.provider._request_kwargs = {"session": MagicMock()}
+                return client
+
+            mock_client_cls.side_effect = create_mock_client
+
+            # Fill cache to limit
+            first_url = "https://first.example.com"
+            get_ethereum_client(first_url)
+            for i in range(1, MAX_CACHED_CLIENTS):
+                get_ethereum_client(f"https://rpc{i}.example.com")
+
+            assert first_url in _ethereum_client_cache
+
+            # Add one more - should evict the first
+            get_ethereum_client("https://new.example.com")
+
+            # First URL should be evicted
+            assert first_url not in _ethereum_client_cache
+            assert "https://new.example.com" in _ethereum_client_cache

iwa/plugins/olas/importer.py

@@ -598,6 +598,15 @@ class OlasServiceImporter:
             content = file_path.read_text().strip()
             keystore = json.loads(content)
 
+            # Handle operate format: keystore is stringified inside "private_key"
+            if "private_key" in keystore and isinstance(keystore["private_key"], str):
+                try:
+                    inner_keystore = json.loads(keystore["private_key"])
+                    if "crypto" in inner_keystore and "address" in inner_keystore:
+                        keystore = inner_keystore
+                except json.JSONDecodeError:
+                    pass  # Not a nested keystore, continue with original
+
             # Validate it's a keystore
             if "crypto" not in keystore or "address" not in keystore:
                 return None

iwa/plugins/olas/plugin.py

@@ -67,10 +67,10 @@ class OlasPlugin(Plugin):
 
         """
         try:
-            from safe_eth.eth import EthereumClient
             from safe_eth.safe import Safe
 
             from iwa.core.chain import ChainInterfaces
+            from iwa.plugins.gnosis.safe import get_ethereum_client
 
             try:
                 chain_interface = ChainInterfaces().get(chain_name)
@@ -79,7 +79,8 @@ class OlasPlugin(Plugin):
             except ValueError:
                 return None, None  # Chain not supported/configured
 
-            ethereum_client = EthereumClient(chain_interface.current_rpc)
+            # Reuse cached EthereumClient to prevent FD exhaustion
+            ethereum_client = get_ethereum_client(chain_interface.current_rpc)
             safe = Safe(safe_address, ethereum_client)
             owners = safe.retrieve_owners()
             return owners, True

iwa/plugins/olas/tui/olas_view.py

@@ -545,10 +545,10 @@ class OlasView(Static):
         """Filter staking contracts based on bond requirements and slots."""
         import json
 
-        from iwa.core.chain import ChainInterface
+        from iwa.core.chain import ChainInterfaces
         from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
 
-        w3 = ChainInterface(self._chain).web3
+        w3 = ChainInterfaces().get(self._chain).web3
         with open(OLAS_ABI_PATH / "staking.json", "r") as f:
             abi = json.load(f)
 
@@ -677,14 +677,14 @@ class OlasView(Static):
         try:
             import json
 
-            from iwa.core.chain import ChainInterface
+            from iwa.core.chain import ChainInterfaces
             from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
             from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
 
             contracts_dict = OLAS_TRADER_STAKING_CONTRACTS.get(self._chain, {})
 
             # Load ABI and check slots for each contract
-            w3 = ChainInterface(self._chain).web3
+            w3 = ChainInterfaces().get(self._chain).web3
             with open(OLAS_ABI_PATH / "staking.json", "r") as f:
                 abi = json.load(f)
 

{iwa-0.0.66.dist-info → iwa-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.66
+Version: 0.1.0
 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.66.dist-info → iwa-0.1.0.dist-info}/RECORD

@@ -23,7 +23,7 @@ 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=lW8jmxQNVrUeoBUuYUx9X5kwUhr-Xw3MHS1RsGQeaRQ,29064
+iwa/core/chain/interface.py,sha256=D_bDIQhQVfY9A2nLPpQ3bipmywoYsi2wVNPXPKutFec,30760
 iwa/core/chain/manager.py,sha256=XHwn7ciapFCZVk0rPSJopUqM5Wu3Kpp6XrenkgTE1HA,1397
 iwa/core/chain/models.py,sha256=WUhAighMKcFdbAUkPU_3dkGbWyAUpRJqXMHLcWFC1xg,5261
 iwa/core/chain/rate_limiter.py,sha256=Ps1MrR4HHtylxgUAawe6DoC9tuqKagjQdKulqcJD2gs,9093
@@ -40,8 +40,8 @@ iwa/core/services/__init__.py,sha256=ab5pYzmu3LrZLTO5N-plx6Rp4R0hBEnbbzsgz84zWGM
 iwa/core/services/account.py,sha256=0l14qD8_-ZbN_hQUNa7bRZt0tkceHPPc4GHmB8UKqy4,2009
 iwa/core/services/balance.py,sha256=MSCEzPRDPlHIjaWD1A2X2oIuiMz5MFJjD7sSHUxQ8OM,3324
 iwa/core/services/plugin.py,sha256=GNNlbtELyHl7MNVChrypF76GYphxXduxDog4kx1MLi8,3277
-iwa/core/services/safe.py,sha256=vqvpk7aIqHljaG1zYYpmKdW4mi5OVuoyXcpReISPYM0,15744
-iwa/core/services/safe_executor.py,sha256=TqpDgtvh8d5cedYAKBj7s1SW7EnomTT9MW_GnYWMxDE,17157
+iwa/core/services/safe.py,sha256=HG3yAN5IdNR45uuHfjAuaT4XVy_tiivoMTQLoEHlEwY,15701
+iwa/core/services/safe_executor.py,sha256=uZIoE_VeB0B9b-HhZ5jNWXna1kr8e_LZ8qEt63kGxIU,17082
 iwa/core/services/transaction.py,sha256=FrGRWn1xo5rbGIr2ToZ2kPzapr3zmWW38oycyB87TK8,19971
 iwa/core/services/transfer/__init__.py,sha256=7p22xtwrH0murXWTuTGNw0WRKBDqjJEnnVaUpWd8Vfo,5589
 iwa/core/services/transfer/base.py,sha256=sohz-Ss2i-pGYGl4x9bD93cnYKcSvsXaXyvyRawvgQs,9043
@@ -58,20 +58,20 @@ iwa/plugins/__init__.py,sha256=zy-DjOZn8GSgIETN2X_GAb9O6yk71t6ZRzeUgoZ52KA,23
 iwa/plugins/gnosis/__init__.py,sha256=dpx0mE84eV-g5iZaH5nKivZJnoKWyRFX5rhdjowBwuU,114
 iwa/plugins/gnosis/cow_utils.py,sha256=iSvbfgTr2bCqRsUznKCWqmoTnyuX-WZX4oh0E-l3XBU,2263
 iwa/plugins/gnosis/plugin.py,sha256=AgkgOGYfnrcjWrPUiAvySMj6ITnss0SFXiEi6Z6fnMs,1885
-iwa/plugins/gnosis/safe.py,sha256=ye5GQhzKALPNiyJhr7lyrhDgdrDyIj_h3TN2QWI4Xds,5519
+iwa/plugins/gnosis/safe.py,sha256=M5Pzyvs2XlygHeyPXoFAFRlECO2l3QeOpYZ38JtuPDM,7799
 iwa/plugins/gnosis/cow/__init__.py,sha256=lZN5QpIYWL67rE8r7z7zS9dlr8OqFrYeD9T4-RwUghU,224
 iwa/plugins/gnosis/cow/quotes.py,sha256=2emu4St016Gf7Nn5P2XW5CcSNxprKoVecdZQ016RpcY,5177
-iwa/plugins/gnosis/cow/swap.py,sha256=XgeMnTDnCiTXVlrrh2pXk4qmjJnFxIVnhZsa1K82uDQ,14729
+iwa/plugins/gnosis/cow/swap.py,sha256=k_keiEa0rLjVUO5aI2-AHt-sXmgwo5eKO2MAuIA8tCg,15123
 iwa/plugins/gnosis/cow/types.py,sha256=-9VRiFhAkmN1iIJ95Pg7zLFSeXtkkW00sl13usxi3o8,470
-iwa/plugins/gnosis/tests/test_cow.py,sha256=50bj9kZ-PwrZXIdTTTNlien5WdDWHhxI44dcB89jOc8,8809
-iwa/plugins/gnosis/tests/test_safe.py,sha256=hQHVHBWQhGnuvzvx4U9fOWEwASJWwql42q6cfRcuAls,3218
+iwa/plugins/gnosis/tests/test_cow.py,sha256=0GoejzZNQJmcUoFaSJL0Rph7fkIZnY5Vp7RdVLyal4I,8714
+iwa/plugins/gnosis/tests/test_safe.py,sha256=ZgqGSsCOWVbqz5WNZ1EQzsgYQMAwJtJ4-7HQNiOlUGo,6584
 iwa/plugins/olas/__init__.py,sha256=_NhBczzM61fhGYwGhnWfEeL8Jywyy_730GASe2BxzeQ,106
 iwa/plugins/olas/constants.py,sha256=BbEDho_TAh10cCGsrlk2vP1OVrS_ZWBE_cAEITd_658,7838
 iwa/plugins/olas/events.py,sha256=HHjYu4pN3tuZATIh8vGWWzDb7z9wuqhsaTqI3_4H0-I,6086
-iwa/plugins/olas/importer.py,sha256=5xTtlQe5hO5bUCOg1sRuFkN2UcohYdJEQwfMm2JckyI,42088
+iwa/plugins/olas/importer.py,sha256=5kFWfzstkIhy6hWevYdbuHUMOnhqpm2STXiF3-pYuYo,42604
 iwa/plugins/olas/mech_reference.py,sha256=CaSCpQnQL4F7wOG6Ox6Zdoy-uNEQ78YBwVLILQZKL8Q,5782
 iwa/plugins/olas/models.py,sha256=VtDjSyc63Yxs3aManmALrcf7asehdQ5f-5Y6MtAdWIk,4056
-iwa/plugins/olas/plugin.py,sha256=kz21CxIGQw3Is6HC2dvKvFRIm9m1FRKHO0YgUuDEplQ,15650
+iwa/plugins/olas/plugin.py,sha256=tW8GCLcWRAxF93hW5awdTwC9njhZiSWKzowb0bWSDRs,15738
 iwa/plugins/olas/contracts/activity_checker.py,sha256=OXh0SFPGfcpeD665ay-I19LqcIx38qEz8o62dw0A9zE,5361
 iwa/plugins/olas/contracts/base.py,sha256=y73aQbDq6l4zUpz_eQAg4MsLkTAEqjjupXlcvxjfgCI,240
 iwa/plugins/olas/contracts/mech.py,sha256=dXYtyORc-oiu9ga5PtTquOFkoakb6BLGKvlUsteygIg,2767
@@ -121,7 +121,7 @@ iwa/plugins/olas/tests/test_service_staking.py,sha256=78yyPoLo51N1aQyDxjzj7I0a26
 iwa/plugins/olas/tests/test_staking_integration.py,sha256=QCBQf6P2ZmmsEGt2k8W2r53lG2aVRuoMJE-aFxVDLss,9701
 iwa/plugins/olas/tests/test_staking_validation.py,sha256=uug64jFcXYJ3Nw_lNa3O4fnhNr5wAWHHIrchSbR2MVE,4020
 iwa/plugins/olas/tui/__init__.py,sha256=5ZRsbC7J3z1xfkZRiwr4bLEklf78rNVjdswe2p7SlS8,28
-iwa/plugins/olas/tui/olas_view.py,sha256=OlhciDK1Ni4BdzggqTzQeYnP2azB-We02hH6jQhbZuU,37388
+iwa/plugins/olas/tui/olas_view.py,sha256=dgZjfXCWsRRdHpygHfSOCJZFWZrgrVyieq-iYgDkK3w,37404
 iwa/tools/__init__.py,sha256=jQyuwDQGRigSe7S9JMb4yK3CXPgZFJNffzt6N2v9PU0,21
 iwa/tools/check_profile.py,sha256=0LAv9wx4wMM610mX88-6tIoDi2I5LDzh0W9nkprt42s,2177
 iwa/tools/drain_accounts.py,sha256=Xd0ephHENms2f5G7IotpFBazPpKrvXoRurctS7fYrc4,1760
@@ -166,7 +166,7 @@ iwa/web/tests/test_web_endpoints.py,sha256=vA25YghHNB23sbmhD4ciesn_f_okSq0tjlkrS
 iwa/web/tests/test_web_olas.py,sha256=GunKEAzcbzL7FoUGMtEl8wqiqwYwA5lB9sOhfCNj0TA,16312
 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.66.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.1.0.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=bgqGM8wJGZjc-BOX6i0K4sh06KCJl-6UAvrwl8x24lA,8324
+tests/test_chain_interface.py,sha256=DhPyIMSWgt0eD8__dW9JB0xb-H0P3TndnOsKeAb3fRg,10501
 tests/test_chain_interface_coverage.py,sha256=fvrVvw8-DMwdsSFKQHUhpbfutrVRxnnTc-tjB7Bb-jo,3327
 tests/test_chainlist_enrichment.py,sha256=hxfYjI54hT2pBXeacmQkLJGEPyuaAwDtNL5sEVZURp8,22065
 tests/test_cli.py,sha256=Pl4RC2xp1omiJUnL3Dza6pCmIoO29LJ0vGw33_ZpT5c,3980
@@ -203,10 +203,10 @@ tests/test_rpc_efficiency.py,sha256=mNuCoa5r6lSEyTqcRX98oz-huoKMTUlKM2UcOHlTQ6M,
 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
+tests/test_safe_coverage.py,sha256=7t77jZeATQJwyVM_CN9EK7EJLGSGJDnOyKo7xrvuFYA,6278
 tests/test_safe_executor.py,sha256=xyiNmPo0Ux3jIcdz5AT98YSmha7Pn3HUDoBtBF6AYRE,25032
 tests/test_safe_integration.py,sha256=WWAKDio3N-CFyr5RRvphbOPdu3TI9WSM8IesfbFbvWQ,5363
-tests/test_safe_service.py,sha256=5ULlj0fPZRwg-4fCBJplhm4Msr_Beof7W-Zf_JljZc8,5782
+tests/test_safe_service.py,sha256=8nrCRuDY3na23HBEvy0UO5iesCsY3ZsuvghyCVuEWLo,6004
 tests/test_service_manager_integration.py,sha256=I_BLUzEKrVTyg_8jqsUK0oFD3aQVPCRJ7z0gY8P-j04,2354
 tests/test_service_manager_structure.py,sha256=zK506ucCXCBHcjPYKrKEuK1bgq0xsbawyL8Y-wahXf8,868
 tests/test_service_transaction.py,sha256=IeqYhmRD-pIXffBJrBQwfPx-qnfNEJs0iPM3eCb8MLo,7054
@@ -224,8 +224,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.66.dist-info/METADATA,sha256=XgG92uv_4y_Td88AjTYAknzLghILTIyM7KwLSbS3MUI,7337
-iwa-0.0.66.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-iwa-0.0.66.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
-iwa-0.0.66.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
-iwa-0.0.66.dist-info/RECORD,,
+iwa-0.1.0.dist-info/METADATA,sha256=w3bjDMNL_NKmol-SCRkwdaY24JaW6LbyL1RZF9jsBiI,7336
+iwa-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iwa-0.1.0.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.1.0.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.1.0.dist-info/RECORD,,

tests/test_chain_interface.py

@@ -208,3 +208,58 @@ def test_reset_rpc_failure_counts(mock_chain_interface):
     interface.reset_rpc_failure_counts()
 
     assert interface._rpc_backoff_until == {}
+
+
+def test_is_fd_exhaustion_error():
+    """Test FD exhaustion error detection."""
+    with patch("iwa.core.chain.interface.get_rate_limiter"):
+        with patch("iwa.core.chain.interface.RateLimitedWeb3"):
+            with patch("iwa.core.chain.models.Gnosis") as mock_gnosis_cls:
+                mock_gnosis = mock_gnosis_cls.return_value
+                mock_gnosis.name = "gnosis"
+                mock_gnosis.rpc = "https://rpc.example.com"
+                mock_gnosis.rpcs = ["https://rpc.example.com"]
+                mock_gnosis.chain_id = 100
+                mock_gnosis.native_currency = "xDAI"
+                mock_gnosis.tokens = {}
+                mock_gnosis.contracts = {}
+
+                interface = ChainInterface(mock_gnosis)
+
+    # Should detect FD exhaustion errors
+    assert interface._is_fd_exhaustion_error(
+        Exception("SSLError(OSError(24, 'Too many open files'))")
+    )
+    assert interface._is_fd_exhaustion_error(
+        Exception("OSError(24, 'Too many open files')")
+    )
+    assert interface._is_fd_exhaustion_error(
+        Exception("errno 24: too many open files")
+    )
+
+    # Should not detect other errors as FD exhaustion
+    assert not interface._is_fd_exhaustion_error(Exception("connection timeout"))
+    assert not interface._is_fd_exhaustion_error(Exception("429 rate limit"))
+    assert not interface._is_fd_exhaustion_error(Exception("500 server error"))
+
+
+def test_handle_fd_exhaustion_no_rotation(mock_chain_interface):
+    """Test FD exhaustion pauses all RPCs without rotating."""
+    interface, _ = mock_chain_interface
+    interface.rotate_rpc = MagicMock(return_value=True)
+
+    # Simulate FD exhaustion error
+    error = Exception("SSLError(OSError(24, 'Too many open files'))")
+    result = interface._handle_rpc_error(error)
+
+    # Should NOT rotate (rotation creates more connections)
+    interface.rotate_rpc.assert_not_called()
+
+    # Should mark for retry after backoff
+    assert result["should_retry"]
+    assert result["is_fd_exhaustion"]
+    assert not result["rotated"]
+
+    # All RPCs should be in backoff
+    for i in range(len(interface.chain.rpcs)):
+        assert not interface._is_rpc_healthy(i)

tests/test_safe_coverage.py

@@ -136,9 +136,12 @@ def test_redeploy_safes(safe_service, mock_deps):
     with patch("iwa.core.chain.models.secrets") as mock_settings:
         mock_settings.gnosis_rpc.get_secret_value.return_value = "http://rpc"
 
-        with patch("iwa.core.services.safe.EthereumClient") as mock_eth_client:
+        # Patch the shared EthereumClient cache function
+        with patch("iwa.plugins.gnosis.safe.get_ethereum_client") as mock_get_client:
             with patch.object(safe_service, "create_safe") as mock_create:
-                mock_w3 = mock_eth_client.return_value.w3
+                mock_eth_client = MagicMock()
+                mock_get_client.return_value = mock_eth_client
+                mock_w3 = mock_eth_client.w3
 
                 # Case 1: Code exists (no redeploy)
                 mock_w3.eth.get_code.return_value = b"code"

tests/test_safe_service.py

@@ -51,6 +51,7 @@ def mock_dependencies():
     """Mock external dependencies (Safe, EthereumClient, etc)."""
     with (
         patch("iwa.core.services.safe.EthereumClient") as mock_client,
+        patch("iwa.plugins.gnosis.safe.get_ethereum_client") as mock_get_client,
         patch("iwa.core.services.safe.Safe") as mock_safe,
         patch("iwa.core.services.safe.ProxyFactory") as mock_proxy_factory,
         patch("iwa.core.services.safe.log_transaction") as mock_log,
@@ -58,6 +59,8 @@ def mock_dependencies():
         patch("iwa.core.services.safe.get_safe_proxy_factory_address") as mock_factory,
         patch("time.sleep"),  # Avoid any retry delays
     ):
+        # Link get_ethereum_client to return the same mock as EthereumClient
+        mock_get_client.return_value = mock_client.return_value
         # Setup Safe creation return
         mock_create_tx = MagicMock()
         # Valid Checksum Address - New Safe (Matches Pydantic output)