iwa 0.0.58__tar.gz → 0.0.60__tar.gz

{iwa-0.0.58/src/iwa.egg-info → iwa-0.0.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.58
+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.58 → iwa-0.0.60}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.58"
+version = "0.0.60"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -72,7 +72,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.0.58"
+target-version = "0.0.60"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.58 → iwa-0.0.60}/src/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,12 @@ 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
+
+    # 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
 
@@ -34,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://"):
@@ -48,6 +54,7 @@ class ChainInterface:
 
         self._initial_block = 0
         self._rotation_lock = threading.Lock()
+        self._session = requests.Session()
         self._init_web3()
 
     @property
@@ -226,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]] = {
@@ -234,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,
         }
@@ -248,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():
@@ -268,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}")
@@ -288,33 +335,40 @@ class ChainInterface:
         return result
 
     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
-
+        """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()
-            if now - self._last_rotation_time < 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)"
-                )
+            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
 
@@ -326,7 +380,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 +467,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 +486,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 +543,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 +559,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 +567,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 +601,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")
 
@@ -572,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-0.0.58 → iwa-0.0.60}/src/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,29 +200,39 @@ class RateLimitedEth:
         return wrapper
 
     def _execute_with_retry(self, method, method_name, *args, **kwargs):
-        """Execute read operation with retry logic."""
-        last_error = None
+        """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:
-                last_error = 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)
 
-        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-0.0.58 → iwa-0.0.60}/src/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-0.0.58 → iwa-0.0.60}/src/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-0.0.58 → iwa-0.0.60}/src/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-0.0.58 → iwa-0.0.60}/src/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-0.0.58 → iwa-0.0.60}/src/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-0.0.60/src/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-0.0.58 → iwa-0.0.60}/src/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-0.0.58 → iwa-0.0.60}/src/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]: