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

iwa/core/chain/interface.py

@@ -4,6 +4,7 @@ import threading
 import time
 from typing import Callable, Dict, Optional, TypeVar, Union
 
+import requests
 from web3 import Web3
 
 from iwa.core.chain.errors import TenderlyQuotaExceededError, sanitize_rpc_url
@@ -23,6 +24,7 @@ class ChainInterface:
 
     DEFAULT_MAX_RETRIES = 6  # Allow trying most/all available RPCs on rate limit
     DEFAULT_RETRY_DELAY = 1.0  # Base delay between retries (exponential backoff)
+    ROTATION_COOLDOWN_SECONDS = 2.0  # Minimum time between RPC rotations
 
     chain: SupportedChain
 
@@ -48,6 +50,7 @@ class ChainInterface:
 
         self._initial_block = 0
         self._rotation_lock = threading.Lock()
+        self._session = requests.Session()
         self._init_web3()
 
     @property
@@ -289,20 +292,17 @@ class ChainInterface:
 
     def rotate_rpc(self) -> bool:
         """Rotate to the next available RPC."""
-        # Minimum time between rotations to prevent cascade rotations from parallel requests
-        # failing simultaneously
-        cooldown_seconds = 2.0
-
         with self._rotation_lock:
             if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
                 return False
 
             # Cooldown: prevent cascade rotations from in-flight requests
             now = time.monotonic()
-            if now - self._last_rotation_time < cooldown_seconds:
+            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"{cooldown_seconds - (now - self._last_rotation_time):.1f}s remaining)"
+                    f"{self.ROTATION_COOLDOWN_SECONDS - elapsed:.1f}s remaining)"
                 )
                 return False
 
@@ -326,7 +326,11 @@ class ChainInterface:
     def _init_web3_under_lock(self):
         """Internal non-thread-safe web3 initialization."""
         rpc_url = self.chain.rpcs[self._current_rpc_index] if self.chain.rpcs else ""
-        raw_web3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": DEFAULT_RPC_TIMEOUT}))
+        raw_web3 = Web3(
+            Web3.HTTPProvider(
+                rpc_url, request_kwargs={"timeout": DEFAULT_RPC_TIMEOUT}, session=self._session
+            )
+        )
 
         # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
         if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
@@ -409,7 +413,9 @@ class ChainInterface:
         except Exception:
             return address[:6] + "..." + address[-4:]
 
-    def get_token_decimals(self, address: EthereumAddress, fallback_to_18: bool = True) -> Optional[int]:
+    def get_token_decimals(
+        self, address: EthereumAddress, fallback_to_18: bool = True
+    ) -> Optional[int]:
         """Get token decimals for an address.
 
         Args:
@@ -426,7 +432,15 @@ class ChainInterface:
             # Use _web3 directly to ensure current provider after RPC rotation
             contract = self.web3._web3.eth.contract(
                 address=self.web3.to_checksum_address(address),
-                abi=[{"constant": True, "inputs": [], "name": "decimals", "outputs": [{"type": "uint8"}], "type": "function"}]
+                abi=[
+                    {
+                        "constant": True,
+                        "inputs": [],
+                        "name": "decimals",
+                        "outputs": [{"type": "uint8"}],
+                        "type": "function",
+                    }
+                ],
             )
             return contract.functions.decimals().call()
         except Exception:
@@ -475,8 +489,10 @@ class ChainInterface:
         # Contract calls already have the target address in the contract object
         if not built_method and "to" in tx_params:
             params["to"] = tx_params["to"]
-        elif not built_method and "to" in params: # Fallback if added to params earlier (though not here yet)
-             pass
+        elif (
+            not built_method and "to" in params
+        ):  # Fallback if added to params earlier (though not here yet)
+            pass
 
         # Determine gas
         if built_method:
@@ -489,11 +505,7 @@ class ChainInterface:
             # Native transfer - dynamic estimation
             try:
                 # web3.eth.estimate_gas returns gas for the dict it receives
-                est_params = {
-                    "from": params["from"],
-                    "to": params["to"],
-                    "value": params["value"]
-                }
+                est_params = {"from": params["from"], "to": params["to"], "value": params["value"]}
                 # Remove None 'to' for contract creation simulation if needed, but usually send() has to
                 if not est_params["to"]:
                     est_params.pop("to")
@@ -501,7 +513,9 @@ class ChainInterface:
                 estimated = self.web3.eth.estimate_gas(est_params)
                 # Apply 10% buffer for safety
                 params["gas"] = int(estimated * 1.1)
-                logger.debug(f"[GAS] Estimated native transfer gas: {params['gas']} (raw: {estimated})")
+                logger.debug(
+                    f"[GAS] Estimated native transfer gas: {params['gas']} (raw: {estimated})"
+                )
             except Exception as e:
                 logger.debug(f"[GAS] Native estimation failed, fallback to 21000: {e}")
                 params["gas"] = 21_000
@@ -533,10 +547,7 @@ class ChainInterface:
                 # Buffer max_fee to handle base fee expansion
                 max_fee = int(base_fee * 1.5) + max_priority_fee
 
-                return {
-                    "maxFeePerGas": max_fee,
-                    "maxPriorityFeePerGas": max_priority_fee
-                }
+                return {"maxFeePerGas": max_fee, "maxPriorityFeePerGas": max_priority_fee}
         except Exception as e:
             logger.debug(f"Failed to calculate EIP-1559 fees: {e}, falling back to legacy")
 

iwa/core/chain/rate_limiter.py

@@ -188,12 +188,10 @@ class RateLimitedEth:
 
     def _execute_with_retry(self, method, method_name, *args, **kwargs):
         """Execute read operation with retry logic."""
-        last_error = None
         for attempt in range(self.DEFAULT_READ_RETRIES + 1):
             try:
                 return method(*args, **kwargs)
             except Exception as e:
-                last_error = e
                 # Use chain interface to handle error (logging, rotation, etc.)
                 result = self._chain_interface._handle_rpc_error(e)
 
@@ -206,10 +204,6 @@ class RateLimitedEth:
                 )
                 time.sleep(delay)
 
-        if last_error:
-            raise last_error
-        raise RuntimeError(f"{method_name} failed unexpectedly")
-
 
 class RateLimitedWeb3:
     """Wrapper around Web3 instance that applies rate limiting transparently."""

iwa/core/chainlist.py

@@ -1,4 +1,5 @@
 """Module for fetching and parsing RPCs from Chainlist.org."""
+
 import json
 import time
 from dataclasses import dataclass
@@ -78,7 +79,7 @@ class ChainlistRPC:
             self.fetch_data()
 
         for entry in self._data:
-            if entry.get('chainId') == chain_id:
+            if entry.get("chainId") == chain_id:
                 return entry
         return None
 
@@ -88,22 +89,25 @@ class ChainlistRPC:
         if not chain_data:
             return []
 
-        raw_rpcs = chain_data.get('rpc', [])
+        raw_rpcs = chain_data.get("rpc", [])
         nodes = []
         for rpc in raw_rpcs:
-            nodes.append(RPCNode(
-                url=rpc.get('url', ''),
-                is_working=True,
-                privacy=rpc.get('privacy'),
-                tracking=rpc.get('tracking')
-            ))
+            nodes.append(
+                RPCNode(
+                    url=rpc.get("url", ""),
+                    is_working=True,
+                    privacy=rpc.get("privacy"),
+                    tracking=rpc.get("tracking"),
+                )
+            )
         return nodes
 
     def get_https_rpcs(self, chain_id: int) -> List[str]:
         """Returns a list of HTTPS RPC URLs for the given chain."""
         rpcs = self.get_rpcs(chain_id)
         return [
-            node.url for node in rpcs
+            node.url
+            for node in rpcs
             if node.url.startswith("https://") or node.url.startswith("http://")
         ]
 
@@ -111,6 +115,7 @@ class ChainlistRPC:
         """Returns a list of WSS RPC URLs for the given chain."""
         rpcs = self.get_rpcs(chain_id)
         return [
-            node.url for node in rpcs
+            node.url
+            for node in rpcs
             if node.url.startswith("wss://") or node.url.startswith("ws://")
         ]

iwa/core/cli.py

@@ -16,13 +16,16 @@ from iwa.tui.app import IwaApp
 
 iwa_cli = typer.Typer(help="iwa command line interface")
 
+
 @iwa_cli.callback()
 def main_callback(ctx: typer.Context):
     """Initialize IWA CLI."""
     # Print banner on startup
     from iwa.core.utils import get_version, print_banner
+
     print_banner("iwa", get_version("iwa"))
 
+
 wallet_cli = typer.Typer(help="Manage wallet")
 
 iwa_cli.add_typer(wallet_cli, name="wallet")

iwa/core/contracts/cache.py

@@ -62,7 +62,7 @@ class ContractCache:
 
         key = self._make_key(contract_cls, address, chain_name)
         now = time.time()
-        expiry = (ttl if ttl is not None else self.ttl)
+        expiry = ttl if ttl is not None else self.ttl
 
         with self._lock:
             # Check if cached and valid

iwa/core/contracts/contract.py

@@ -31,6 +31,7 @@ def clear_abi_cache() -> None:
     global _ABI_CACHE
     _ABI_CACHE = {}
 
+
 # Panic codes (from Solidity)
 # ... (rest of PANIC_CODES) ...
 PANIC_CODES = {

iwa/core/contracts/decoder.py

@@ -58,7 +58,7 @@ class ErrorDecoder:
         # Also check core ABIs if they are in a different place
         core_abi_path = src_root / "iwa" / "core" / "contracts" / "abis"
         if core_abi_path.exists() and core_abi_path not in [f.parent for f in abi_files]:
-             abi_files.extend(list(core_abi_path.glob("*.json")))
+            abi_files.extend(list(core_abi_path.glob("*.json")))
 
         logger.debug(f"Found {len(abi_files)} ABI files for error decoding.")
 
@@ -66,7 +66,11 @@ class ErrorDecoder:
             try:
                 with open(abi_path, "r", encoding="utf-8") as f:
                     content = json.load(f)
-                    abi = content.get("abi") if isinstance(content, dict) and "abi" in content else content
+                    abi = (
+                        content.get("abi")
+                        if isinstance(content, dict) and "abi" in content
+                        else content
+                    )
                     if isinstance(abi, list):
                         self._process_abi(abi, abi_path.name)
             except Exception as e:
@@ -91,7 +95,7 @@ class ErrorDecoder:
                     "types": types,
                     "arg_names": names,
                     "source": source_name,
-                    "signature": signature
+                    "signature": signature,
                 }
 
                 if selector not in self._selectors:
@@ -145,7 +149,9 @@ class ErrorDecoder:
             for d in self._selectors[selector]:
                 try:
                     decoded = decode(d["types"], bytes.fromhex(encoded_args))
-                    args_str = ", ".join(f"{n}={v}" for n, v in zip(d["arg_names"], decoded, strict=False))
+                    args_str = ", ".join(
+                        f"{n}={v}" for n, v in zip(d["arg_names"], decoded, strict=False)
+                    )
                     results.append((d["name"], f"{d['name']}({args_str})", d["source"]))
                 except Exception:
                     # Try next possible decoding for this selector

iwa/core/http.py

@@ -0,0 +1,31 @@
+"""Shared HTTP session utilities."""
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+DEFAULT_RETRY_TOTAL = 3
+DEFAULT_BACKOFF_FACTOR = 1
+DEFAULT_STATUS_FORCELIST = [429, 500, 502, 503, 504]
+
+
+def create_retry_session(
+    retries: int = DEFAULT_RETRY_TOTAL,
+    backoff_factor: int = DEFAULT_BACKOFF_FACTOR,
+    status_forcelist: list[int] | None = None,
+) -> requests.Session:
+    """Create a requests.Session with retry strategy.
+
+    Used by PriceService, IPFS, and other modules that need
+    persistent HTTP connections with automatic retry.
+    """
+    session = requests.Session()
+    retry_strategy = Retry(
+        total=retries,
+        backoff_factor=backoff_factor,
+        status_forcelist=status_forcelist or DEFAULT_STATUS_FORCELIST,
+    )
+    adapter = HTTPAdapter(max_retries=retry_strategy)
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+    return session

iwa/core/ipfs.py

@@ -12,14 +12,15 @@ from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
 import aiohttp
 from multiformats import CID
 
+from iwa.core.http import create_retry_session
 from iwa.core.models import Config
 
 if TYPE_CHECKING:
     import requests
 
-# Global session for sync requests
+# Global persistent sessions (reused across calls to prevent FD leaks)
 _SYNC_SESSION: Optional["requests.Session"] = None
-
+_ASYNC_SESSION: Optional[aiohttp.ClientSession] = None
 
 
 def _compute_cid_v1_hex(data: bytes) -> str:
@@ -63,10 +64,13 @@ async def push_to_ipfs_async(
     form = aiohttp.FormData()
     form.add_field("file", data, filename="data", content_type="application/octet-stream")
 
-    async with aiohttp.ClientSession() as session:
-        async with session.post(endpoint, data=form, params=params) as response:
-            response.raise_for_status()
-            result = await response.json()
+    global _ASYNC_SESSION
+    if _ASYNC_SESSION is None or _ASYNC_SESSION.closed:
+        _ASYNC_SESSION = aiohttp.ClientSession()
+
+    async with _ASYNC_SESSION.post(endpoint, data=form, params=params) as response:
+        response.raise_for_status()
+        result = await response.json()
 
     cid_str = result["Hash"]
     cid = CID.decode(cid_str)
@@ -90,22 +94,10 @@ def push_to_ipfs_sync(
     :param pin: Whether to pin the content (default True).
     :return: Tuple of (CIDv1 string, CIDv1 hex representation).
     """
-    import requests
-    from requests.adapters import HTTPAdapter
-    from urllib3.util.retry import Retry
-
     global _SYNC_SESSION
 
     if _SYNC_SESSION is None:
-        _SYNC_SESSION = requests.Session()
-        retry_strategy = Retry(
-            total=3,
-            backoff_factor=1,
-            status_forcelist=[429, 500, 502, 503, 504],
-        )
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        _SYNC_SESSION.mount("http://", adapter)
-        _SYNC_SESSION.mount("https://", adapter)
+        _SYNC_SESSION = create_retry_session()
 
     url = api_url or Config().core.ipfs_api_url
     endpoint = f"{url}/api/v0/add"

iwa/core/keys.py

@@ -249,7 +249,7 @@ class KeyStorage(BaseModel):
 
         with open(self._path, "w", encoding="utf-8") as f:
             # Use mode='json' to ensure all types (EthereumAddress) are correctly serialized
-            json.dump(self.model_dump(mode='json'), f, indent=4)
+            json.dump(self.model_dump(mode="json"), f, indent=4)
             f.flush()
             os.fsync(f.fileno())  # Force write to disk (critical for Docker volumes)
 
@@ -376,10 +376,14 @@ class KeyStorage(BaseModel):
             # Check for duplicate tags
             for existing in self.accounts.values():
                 if existing.tag == account.tag and existing.address != account.address:
-                    raise ValueError(f"Tag '{account.tag}' is already used by address {existing.address}")
+                    raise ValueError(
+                        f"Tag '{account.tag}' is already used by address {existing.address}"
+                    )
 
         self.accounts[account.address] = account
-        logger.info(f"[KeyStorage] Registering account: tag='{account.tag}', address={account.address}")
+        logger.info(
+            f"[KeyStorage] Registering account: tag='{account.tag}', address={account.address}"
+        )
         self.save()
 
     def get_pending_mnemonic(self) -> Optional[str]:
@@ -460,7 +464,9 @@ class KeyStorage(BaseModel):
 
         old_tag = account.tag
         account.tag = new_tag
-        logger.info(f"[KeyStorage] Renaming account: '{old_tag}' -> '{new_tag}' (address={account.address})")
+        logger.info(
+            f"[KeyStorage] Renaming account: '{old_tag}' -> '{new_tag}' (address={account.address})"
+        )
         self.save()
 
     def _get_private_key(self, address: str) -> Optional[str]:

iwa/core/models.py

@@ -80,9 +80,7 @@ class CoreConfig(BaseModel):
     tenderly_olas_funds: float = Field(default=100000.0, description="OLAS amount for vNet funding")
 
     # Safe Transaction Retry System
-    safe_tx_max_retries: int = Field(
-        default=6, description="Maximum retries for Safe transactions"
-    )
+    safe_tx_max_retries: int = Field(default=6, description="Maximum retries for Safe transactions")
     safe_tx_gas_buffer: float = Field(
         default=1.5, description="Gas buffer multiplier for Safe transactions"
     )

iwa/core/pricing.py

@@ -4,9 +4,9 @@ import time
 from datetime import datetime, timedelta
 from typing import Dict, Optional
 
-import requests
 from loguru import logger
 
+from iwa.core.http import create_retry_session
 from iwa.core.secrets import secrets
 
 # Global cache shared across all PriceService instances
@@ -28,28 +28,12 @@ class PriceService:
             if self.secrets.coingecko_api_key
             else None
         )
-        self.session = requests.Session()
-        # Configure retry strategy
-        from requests.adapters import HTTPAdapter
-        from urllib3.util.retry import Retry
-
-        retry_strategy = Retry(
-            total=3,
-            backoff_factor=1,
-            status_forcelist=[429, 500, 502, 503, 504],
-        )
-        adapter = HTTPAdapter(max_retries=retry_strategy)
-        self.session.mount("https://", adapter)
-        self.session.mount("http://", adapter)
+        self.session = create_retry_session()
 
     def close(self):
         """Close the session."""
         self.session.close()
 
-    def __del__(self):
-        """Cleanup on deletion."""
-        self.close()
-
     def get_token_price(self, token_id: str, vs_currency: str = "eur") -> Optional[float]:
         """Get token price in specified currency.
 
@@ -115,9 +99,7 @@ class PriceService:
                     return float(data[token_id][vs_currency])
 
                 # If we got response but price not found, it's likely a wrong ID
-                logger.debug(
-                    f"Price for {token_id} in {vs_currency} not found in response: {data}"
-                )
+                logger.debug(f"Price for {token_id} in {vs_currency} not found in response: {data}")
                 return None
 
             except Exception as e:

iwa/core/rpc_monitor.py

@@ -1,4 +1,5 @@
 """RPC Monitor for tracking API usage."""
+
 import threading
 from collections import defaultdict
 from typing import Dict

iwa/core/services/balance.py

@@ -88,4 +88,3 @@ class BalanceService:
 
         contract = ERC20Contract(chain_name=chain_name, address=token_address)
         return contract.balance_of_wei(account.address)
-

iwa/core/services/safe.py

@@ -1,6 +1,6 @@
 """Safe service module."""
 
-from typing import TYPE_CHECKING, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from loguru import logger
 from safe_eth.eth import EthereumClient
@@ -35,6 +35,7 @@ class SafeService:
         """Initialize SafeService."""
         self.key_storage = key_storage
         self.account_service = account_service
+        self._client_cache: Dict[str, EthereumClient] = {}
 
     def create_safe(
         self,
@@ -102,7 +103,12 @@ class SafeService:
 
         # Use ChainInterface which has proper RPC rotation and parsing
         chain_interface = ChainInterfaces().get(chain_name)
-        return EthereumClient(chain_interface.current_rpc)
+        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]
 
     def _deploy_safe_contract(
         self,