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

iwa/core/chain/interface.py

@@ -54,9 +54,41 @@ class ChainInterface:
 
         self._initial_block = 0
         self._rotation_lock = threading.Lock()
-        self._session = requests.Session()
+        self._session = self._create_session()
+
+        # Enrich with public RPCs from ChainList (skip for Tenderly vNets)
+        if not self.is_tenderly:
+            self._enrich_rpcs_from_chainlist()
+
         self._init_web3()
 
+    def _create_session(self) -> requests.Session:
+        """Create a requests Session with bounded connection pooling.
+
+        Configures the session with limited pool sizes to prevent file
+        descriptor exhaustion during RPC rotations. Connections are reused
+        within the pool but won't accumulate unboundedly.
+        """
+        session = requests.Session()
+        # Limit pool size: we only talk to one RPC at a time, but may rotate
+        # through multiple during the session lifetime. Keep modest limits.
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=5,  # Max different hosts to keep connections to
+            pool_maxsize=10,  # Max connections per host
+        )
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        return session
+
+    def close(self) -> None:
+        """Close the session and release all connections.
+
+        Call this when the ChainInterface is no longer needed to ensure
+        proper cleanup of network resources.
+        """
+        if hasattr(self, "_session") and self._session:
+            self._session.close()
+
     @property
     def current_rpc(self) -> str:
         """Get the current active RPC URL."""
@@ -251,6 +283,39 @@ class ChainInterface:
         ]
         return any(signal in err_text for signal in quota_signals)
 
+    # -- ChainList enrichment ----------------------------------------------
+
+    MAX_RPCS = 20  # Cap total RPCs per chain
+
+    def _enrich_rpcs_from_chainlist(self) -> None:
+        """Add validated public RPCs from ChainList to the rotation pool."""
+        if len(self.chain.rpcs) >= self.MAX_RPCS:
+            logger.debug(
+                f"{self.chain.name}: skipping ChainList enrichment "
+                f"(already have {len(self.chain.rpcs)} RPCs)"
+            )
+            return
+
+        try:
+            from iwa.core.chainlist import ChainlistRPC
+
+            chainlist = ChainlistRPC()
+            extra = chainlist.get_validated_rpcs(
+                self.chain.chain_id,
+                existing_rpcs=self.chain.rpcs,
+                max_results=self.MAX_RPCS - len(self.chain.rpcs),
+            )
+            if extra:
+                self.chain.rpcs.extend(extra)
+                logger.info(
+                    f"Enriched {self.chain.name} with {len(extra)} "
+                    f"ChainList RPCs (total: {len(self.chain.rpcs)})"
+                )
+        except Exception as e:
+            logger.debug(
+                f"ChainList enrichment failed for {self.chain.name}: {e}"
+            )
+
     # -- Per-RPC health tracking ------------------------------------------
 
     def _mark_rpc_backoff(self, index: int, seconds: float) -> None:
@@ -293,35 +358,45 @@ class ChainInterface:
 
         if should_rotate:
             failed_index = self._current_rpc_index
+            failed_rpc = sanitize_rpc_url(self.chain.rpcs[failed_index]) if self.chain.rpcs else "?"
 
             # 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)
+                error_type = "QUOTA"
+                backoff = self.QUOTA_EXCEEDED_BACKOFF
+                self._mark_rpc_backoff(failed_index, backoff)
             elif result["is_rate_limit"]:
-                error_type = "rate limit"
-                self._mark_rpc_backoff(failed_index, self.RATE_LIMIT_BACKOFF)
+                error_type = "RATE_LIMIT"
+                backoff = self.RATE_LIMIT_BACKOFF
+                self._mark_rpc_backoff(failed_index, 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)
+                error_type = "CONNECTION"
+                backoff = self.CONNECTION_ERROR_BACKOFF
+                self._mark_rpc_backoff(failed_index, backoff)
+
+            # Count healthy RPCs for visibility
+            healthy_count = sum(1 for i in range(len(self.chain.rpcs)) if self._is_rpc_healthy(i))
+            total_rpcs = len(self.chain.rpcs) if self.chain.rpcs else 0
 
             logger.warning(
-                f"RPC {error_type} error on {self.chain.name} "
-                f"(RPC #{failed_index}): {error}"
+                f"[{self.chain.name}] RPC #{failed_index} {error_type} → "
+                f"backoff {int(backoff)}s ({healthy_count}/{total_rpcs} healthy) | "
+                f"{failed_rpc}: {str(error)[:100]}"
             )
 
             if self.rotate_rpc():
                 result["rotated"] = True
                 result["should_retry"] = True
-                logger.info(f"Rotated to RPC #{self._current_rpc_index} for {self.chain.name}")
+                new_rpc = sanitize_rpc_url(self.chain.rpcs[self._current_rpc_index])
+                logger.info(f"[{self.chain.name}] Rotated to RPC #{self._current_rpc_index}: {new_rpc}")
             else:
                 # 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}"
+                logger.debug(
+                    f"[{self.chain.name}] Rotation skipped (cooldown), retrying RPC #{self._current_rpc_index}"
                 )
 
         elif result["is_server_error"]:

iwa/core/chain/manager.py

@@ -36,3 +36,11 @@ class ChainInterfaces:
         for name, interface in self.items():
             results[name] = interface.check_rpc_health()
         return results
+
+    def close_all(self) -> None:
+        """Close all chain interface sessions.
+
+        Call this at application shutdown to release network resources.
+        """
+        for _, interface in self.items():
+            interface.close()

iwa/core/chainlist.py

@@ -2,12 +2,158 @@
 
 import json
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import requests
 
 from iwa.core.constants import CACHE_DIR
+from iwa.core.utils import configure_logger
+
+logger = configure_logger()
+
+# -- RPC probing constants --------------------------------------------------
+
+MAX_CHAINLIST_CANDIDATES = 15  # Probe at most this many candidates
+PROBE_TIMEOUT = 5.0  # Seconds per probe request
+MAX_BLOCK_LAG = 10  # Blocks behind majority → considered stale
+
+
+def _normalize_url(url: str) -> str:
+    """Normalize an RPC URL for deduplication (lowercase, strip trailing slash)."""
+    return url.rstrip("/").lower()
+
+
+def _is_template_url(url: str) -> bool:
+    """Return True if the URL contains template variables requiring an API key."""
+    return "${" in url or "{" in url
+
+
+def probe_rpc(
+    url: str,
+    timeout: float = PROBE_TIMEOUT,
+    session: Optional[requests.Session] = None,
+) -> Optional[Tuple[str, float, int]]:
+    """Probe an RPC endpoint with eth_blockNumber.
+
+    Returns ``(url, latency_ms, block_number)`` on success, or ``None``
+    if the endpoint is unreachable, slow, or returns invalid data.
+
+    Args:
+        url: The RPC endpoint URL to probe.
+        timeout: Request timeout in seconds.
+        session: Optional requests.Session for connection reuse. If None,
+                 creates a temporary session that is properly closed.
+
+    """
+    # Use provided session or create temporary one with proper cleanup
+    own_session = session is None
+    if own_session:
+        session = requests.Session()
+
+    try:
+        start = time.monotonic()
+        resp = session.post(
+            url,
+            json={"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1},
+            timeout=timeout,
+        )
+        latency_ms = (time.monotonic() - start) * 1000
+        data = resp.json()
+        block_hex = data.get("result")
+        if not block_hex or not isinstance(block_hex, str) or block_hex == "0x0":
+            return None
+        return (url, latency_ms, int(block_hex, 16))
+    except Exception:
+        return None
+    finally:
+        if own_session:
+            session.close()
+
+
+def _filter_candidates(
+    nodes: "List[RPCNode]",
+    existing_normalized: set,
+) -> List[str]:
+    """Filter ChainList nodes to usable HTTPS candidates."""
+    candidates: List[str] = []
+    for node in nodes:
+        url = node.url
+        if not url.startswith("https://"):
+            continue
+        if _is_template_url(url):
+            continue
+        if _normalize_url(url) in existing_normalized:
+            continue
+        candidates.append(url)
+        if len(candidates) >= MAX_CHAINLIST_CANDIDATES:
+            break
+    return candidates
+
+
+def _probe_candidates(
+    candidates: List[str],
+) -> List[Tuple[str, float, int]]:
+    """Probe a list of RPC URLs in parallel, returning successful results.
+
+    Uses a shared session for all probes to enable connection pooling and
+    ensure proper cleanup of all connections when probing completes.
+    """
+    results: List[Tuple[str, float, int]] = []
+    # Use a shared session with connection pooling for all probes
+    # This prevents FD leaks from individual probe connections
+    with requests.Session() as session:
+        # Configure connection pool size to match our max workers
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=10,
+            pool_maxsize=10,
+            max_retries=0,  # No retries - we handle failure gracefully
+        )
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+
+        with ThreadPoolExecutor(max_workers=min(len(candidates), 10)) as pool:
+            futures = {
+                pool.submit(probe_rpc, url, PROBE_TIMEOUT, session): url
+                for url in candidates
+            }
+            for future in as_completed(futures, timeout=15):
+                try:
+                    result = future.result()
+                    if result is not None:
+                        results.append(result)
+                except Exception:
+                    pass
+    # Session is closed here via context manager, releasing all connections
+    return results
+
+
+def _rank_and_select(
+    results: List[Tuple[str, float, int]],
+    candidates: List[str],
+    chain_id: int,
+    max_results: int,
+) -> List[str]:
+    """Rank probed RPCs by latency, filtering stale ones."""
+    blocks = sorted(r[2] for r in results)
+    median_block = blocks[len(blocks) // 2]
+
+    valid = [
+        (url, latency)
+        for url, latency, block in results
+        if median_block - block <= MAX_BLOCK_LAG
+    ]
+    valid.sort(key=lambda x: x[1])
+
+    selected = [url for url, _ in valid[:max_results]]
+    if selected:
+        logger.info(
+            f"ChainList: validated {len(selected)}/{len(candidates)} "
+            f"candidates for chain {chain_id} "
+            f"(median block: {median_block})"
+        )
+    return selected
 
 
 @dataclass
@@ -50,11 +196,12 @@ class ChainlistRPC:
             except Exception as e:
                 print(f"Error reading Chainlist cache: {e}")
 
-        # 2. Fetch from remote
+        # 2. Fetch from remote (use session context for proper cleanup)
         try:
-            response = requests.get(self.URL, timeout=10)
-            response.raise_for_status()
-            self._data = response.json()
+            with requests.Session() as session:
+                response = session.get(self.URL, timeout=10)
+                response.raise_for_status()
+                self._data = response.json()
 
             # 3. Update local cache
             if self._data:
@@ -119,3 +266,34 @@ class ChainlistRPC:
             for node in rpcs
             if node.url.startswith("wss://") or node.url.startswith("ws://")
         ]
+
+    def get_validated_rpcs(
+        self,
+        chain_id: int,
+        existing_rpcs: List[str],
+        max_results: int = 5,
+    ) -> List[str]:
+        """Return ChainList RPCs filtered, probed, and sorted by quality.
+
+        1. Fetch HTTPS RPCs from ChainList for *chain_id*.
+        2. Filter out template URLs, duplicates of *existing_rpcs*, and
+           websocket endpoints.
+        3. Probe the top candidates in parallel with ``eth_blockNumber``.
+        4. Discard RPCs that are stale (block number lagging behind majority).
+        5. Return up to *max_results* URLs sorted by latency (fastest first).
+        """
+        nodes = self.get_rpcs(chain_id)
+        if not nodes:
+            return []
+
+        existing_normalized = {_normalize_url(u) for u in existing_rpcs}
+        candidates = _filter_candidates(nodes, existing_normalized)
+        if not candidates:
+            return []
+
+        results = _probe_candidates(candidates)
+        if not results:
+            return []
+
+        selected = _rank_and_select(results, candidates, chain_id, max_results)
+        return selected

iwa/core/services/safe_executor.py

@@ -39,6 +39,10 @@ class SafeTransactionExecutor:
     MAX_GAS_MULTIPLIER = 10  # Hard cap: never exceed 10x original estimate
     DEFAULT_FALLBACK_GAS = 500_000  # Fallback when estimation fails
 
+    # Fee bumping for "max fee per gas less than block base fee" errors
+    FEE_BUMP_PERCENTAGE = 1.30  # 30% bump per retry on fee errors
+    MAX_FEE_BUMP_FACTOR = 3.0  # Cap: never bump more than 3x original
+
     def __init__(
         self,
         chain_interface: "ChainInterface",
@@ -76,6 +80,7 @@ class SafeTransactionExecutor:
         last_error = None
         current_gas = safe_tx.safe_tx_gas
         base_estimate = current_gas if current_gas > 0 else 0
+        fee_bump_factor = 1.0  # Multiplier for EIP-1559 fees, increases on fee errors
 
         for attempt in range(self.max_retries + 1):
             SAFE_TX_STATS["total_attempts"] += 1
@@ -89,6 +94,7 @@ class SafeTransactionExecutor:
                     attempt,
                     current_gas,
                     base_estimate,
+                    fee_bump_factor,
                 )
 
                 # Check receipt
@@ -106,7 +112,7 @@ class SafeTransactionExecutor:
                 raise ValueError("Transaction reverted on-chain")
 
             except Exception as e:
-                updated_tx, should_retry = self._handle_execution_failure(
+                updated_tx, should_retry, is_fee_error = self._handle_execution_failure(
                     e, safe_address, safe_tx, attempt, operation_name
                 )
                 last_error = e
@@ -115,7 +121,12 @@ class SafeTransactionExecutor:
 
                 # Update gas/nonce for next loop if needed
                 safe_tx = updated_tx
-                # If gas error, gas is recalculated in next _execute_attempt via fresh estimation
+
+                # Bump fee multiplier on fee-related errors (base fee > max fee)
+                if is_fee_error and fee_bump_factor < self.MAX_FEE_BUMP_FACTOR:
+                    fee_bump_factor *= self.FEE_BUMP_PERCENTAGE
+                    fee_bump_factor = min(fee_bump_factor, self.MAX_FEE_BUMP_FACTOR)
+                    logger.info(f"[{operation_name}] Fee bump factor increased to {fee_bump_factor:.2f}x")
 
                 delay = self.DEFAULT_RETRY_DELAY * (2**attempt)
                 time.sleep(delay)
@@ -131,6 +142,7 @@ class SafeTransactionExecutor:
         attempt,
         current_gas,
         base_estimate,
+        fee_bump_factor: float = 1.0,
     ) -> str:
         """Prepare client, estimate gas, simulate, and execute."""
         # 1. (Re)Create Safe client
@@ -171,24 +183,11 @@ class SafeTransactionExecutor:
         signatures_backup = safe_tx.signatures
 
         try:
-            # Always pass the first signer key as the executor (gas payer).
-            # Note: This method does NOT re-sign the Safe hash if signatures are already present.
-            # Use EIP-1559 'FAST' to ensure adequate priority fee (fixes Gnosis FeeTooLow)
-            result = safe_tx.execute(signer_keys[0], eip1559_speed=TxSpeed.FAST)
-
-            # Handle both tuple return (tx_hash, tx) and bytes return
-            if isinstance(result, tuple):
-                tx_hash_bytes = result[0]
-            else:
-                tx_hash_bytes = result
-
-            # Handle both bytes and hex string returns
-            if isinstance(tx_hash_bytes, bytes):
-                return f"0x{tx_hash_bytes.hex()}"
-            elif isinstance(tx_hash_bytes, str):
-                return tx_hash_bytes if tx_hash_bytes.startswith("0x") else f"0x{tx_hash_bytes}"
-            else:
-                return str(tx_hash_bytes)
+            # Execute with appropriate gas pricing
+            result = self._execute_with_gas_pricing(
+                safe_tx, signer_keys[0], fee_bump_factor, operation_name
+            )
+            return self._extract_tx_hash(result)
 
         finally:
             # Restore signatures for next attempt if needed
@@ -196,6 +195,39 @@ class SafeTransactionExecutor:
             if safe_tx.signatures != signatures_backup:
                 safe_tx.signatures = signatures_backup
 
+    def _execute_with_gas_pricing(
+        self, safe_tx: SafeTx, signer_key: str, fee_bump_factor: float, operation_name: str
+    ):
+        """Execute transaction with appropriate gas pricing strategy.
+
+        If fee_bump_factor > 1.0, calculates a bumped gas price to overcome
+        base fee volatility. Otherwise uses EIP-1559 FAST speed.
+        """
+        if fee_bump_factor > 1.0:
+            bumped_gas_price = self._calculate_bumped_gas_price(fee_bump_factor)
+            if bumped_gas_price:
+                logger.debug(
+                    f"[{operation_name}] Using bumped gas price: {bumped_gas_price} wei "
+                    f"(factor: {fee_bump_factor:.2f}x)"
+                )
+                return safe_tx.execute(signer_key, tx_gas_price=bumped_gas_price)
+            # Fallback to FAST if calculation fails
+            return safe_tx.execute(signer_key, eip1559_speed=TxSpeed.FAST)
+        # Default: use EIP-1559 'FAST' speed
+        return safe_tx.execute(signer_key, eip1559_speed=TxSpeed.FAST)
+
+    def _extract_tx_hash(self, result) -> str:
+        """Extract transaction hash from execute() result."""
+        # Handle both tuple return (tx_hash, tx) and bytes return
+        tx_hash_bytes = result[0] if isinstance(result, tuple) else result
+
+        # Handle both bytes and hex string returns
+        if isinstance(tx_hash_bytes, bytes):
+            return f"0x{tx_hash_bytes.hex()}"
+        if isinstance(tx_hash_bytes, str):
+            return tx_hash_bytes if tx_hash_bytes.startswith("0x") else f"0x{tx_hash_bytes}"
+        return str(tx_hash_bytes)
+
     def _check_receipt_status(self, receipt) -> bool:
         """Check if receipt has successful status."""
         status = getattr(receipt, "status", None)
@@ -210,14 +242,20 @@ class SafeTransactionExecutor:
         safe_tx: SafeTx,
         attempt: int,
         operation_name: str,
-    ) -> Tuple[SafeTx, bool]:
-        """Handle execution failure and determine next steps."""
+    ) -> Tuple[SafeTx, bool, bool]:
+        """Handle execution failure and determine next steps.
+
+        Returns:
+            Tuple of (updated_safe_tx, should_retry, is_fee_error)
+
+        """
         classification = self._classify_error(error)
+        is_fee_error = classification["is_fee_error"]
 
         if attempt >= self.max_retries:
             SAFE_TX_STATS["final_failures"] += 1
             logger.error(f"[{operation_name}] Failed after {attempt + 1} attempts: {error}")
-            return safe_tx, False
+            return safe_tx, False, is_fee_error
 
         strategy = "retry"
         safe = self._recreate_safe_client(safe_address)
@@ -231,13 +269,16 @@ class SafeTransactionExecutor:
             SAFE_TX_STATS["rpc_rotations"] += 1
             result = self.chain_interface._handle_rpc_error(error)
             if not result["should_retry"]:
-                return safe_tx, False
+                return safe_tx, False, is_fee_error
+        elif is_fee_error:
+            strategy = "fee bump"
+            SAFE_TX_STATS["gas_retries"] += 1
         elif classification["is_gas_error"]:
             strategy = "gas increase"
-            # Gas increase handled in next attempt loop
+            SAFE_TX_STATS["gas_retries"] += 1
 
         self._log_retry(attempt + 1, error, strategy)
-        return safe_tx, True
+        return safe_tx, True, is_fee_error
 
     def _estimate_safe_tx_gas(self, safe: Safe, safe_tx: SafeTx, base_estimate: int = 0) -> int:
         """Estimate gas for a Safe transaction with buffer and hard cap."""
@@ -320,14 +361,57 @@ class SafeTransactionExecutor:
             error
         ) or self.chain_interface._is_connection_error(error)
 
+        # Fee-specific errors: base fee jumped above our max fee
+        fee_error_signals = [
+            "max fee per gas less than block base fee",
+            "maxfeepergas",
+            "fee too low",
+            "underpriced",
+        ]
+        is_fee_error = any(signal in err_text for signal in fee_error_signals)
+
         return {
             "is_gas_error": any(x in err_text for x in ["gas", "out of gas", "intrinsic"]),
+            "is_fee_error": is_fee_error,
             "is_nonce_error": self._is_nonce_error(error),
             "is_rpc_error": is_rpc,
             "is_revert": "revert" in err_text or "execution reverted" in err_text,
             "is_signature_error": self._is_signature_error(error),
         }
 
+    def _calculate_bumped_gas_price(self, bump_factor: float) -> Optional[int]:
+        """Calculate a bumped gas price based on current base fee.
+
+        Uses legacy gas price (not EIP-1559) for compatibility with safe-eth-py's
+        tx_gas_price parameter. The bumped price ensures we're above the current
+        base fee even if it's volatile.
+
+        Args:
+            bump_factor: Multiplier to apply to the base fee (e.g., 1.3 = 30% bump)
+
+        Returns:
+            Gas price in wei, or None if calculation fails
+
+        """
+        try:
+            web3 = self.chain_interface.web3
+            latest_block = web3.eth.get_block("latest")
+            base_fee = latest_block.get("baseFeePerGas")
+
+            if base_fee is not None:
+                # EIP-1559 chain: calculate bumped max fee
+                # base_fee * bump_factor * 1.5 (extra buffer) + priority fee
+                priority_fee = max(int(web3.eth.max_priority_fee), 1)
+                bumped_fee = int(base_fee * bump_factor * 1.5) + priority_fee
+                return bumped_fee
+            else:
+                # Legacy chain: bump the gas price directly
+                gas_price = web3.eth.gas_price
+                return int(gas_price * bump_factor)
+        except Exception as e:
+            logger.debug(f"Failed to calculate bumped gas price: {e}")
+            return None
+
     def _decode_revert_reason(self, error: Exception) -> Optional[str]:
         """Attempt to decode the revert reason."""
         import re

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

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

@@ -1,7 +1,7 @@
 iwa/__init__.py,sha256=vu12UytYNREtMRvIWp6AfV1GgUe53XWwCMhYyqKAPgo,19
 iwa/__main__.py,sha256=eJU5Uxeu9Y7shWg5dt5Mcq0pMC4wFVNWjeYGKSf4Apw,88
 iwa/core/__init__.py,sha256=GJv4LJOXeZ3hgGvbt5I6omkoFkP2A9qhHjpDlOep9ik,24
-iwa/core/chainlist.py,sha256=bcbv1P9R-RiCghullse0qVmqkTs1l4_ZOkOHZ0MzjtI,4097
+iwa/core/chainlist.py,sha256=OraylOuaGXR65p7HNkEssjQzQe5as1WxZoRlxQFYVho,10187
 iwa/core/cli.py,sha256=Qo0SXvgKFOd3Ru-LnX5zEXIaR7r3uwYoqwPhVShEqiQ,8315
 iwa/core/constants.py,sha256=_CYUVQpR--dRPuxotsmbzQE-22y61tlnjUD7IhlvVVA,997
 iwa/core/db.py,sha256=WI-mP0tQAmwFPeEi9w7RCa_Mcf_zBfd_7JcbHJwU1aU,10377
@@ -23,8 +23,8 @@ 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=ww779Wek8qeIxu5t0v3hcmwXq7dMaxp0TjpW4Eikg8Y,25924
-iwa/core/chain/manager.py,sha256=cFEzh6pK5OyVhjhpeMAqhc9RnRDQR1DjIGiGKp-FXBI,1159
+iwa/core/chain/interface.py,sha256=lW8jmxQNVrUeoBUuYUx9X5kwUhr-Xw3MHS1RsGQeaRQ,29064
+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
 iwa/core/contracts/__init__.py,sha256=P5GFY_pnuI02teqVY2U0t98bn1_SSPAbcAzRMpCdTi4,34
@@ -41,7 +41,7 @@ iwa/core/services/account.py,sha256=0l14qD8_-ZbN_hQUNa7bRZt0tkceHPPc4GHmB8UKqy4,
 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=e7M4Z0w00W5H88I1Yf2qQGP_orI5FDDVSzgilhJaeQo,13509
+iwa/core/services/safe_executor.py,sha256=TqpDgtvh8d5cedYAKBj7s1SW7EnomTT9MW_GnYWMxDE,17157
 iwa/core/services/transaction.py,sha256=FrGRWn1xo5rbGIr2ToZ2kPzapr3zmWW38oycyB87TK8,19971
 iwa/core/services/transfer/__init__.py,sha256=ZJfshFxJRsp8rkOqfVvd1cqEzIJ9tqBJh8pc0l90GLk,5576
 iwa/core/services/transfer/base.py,sha256=sohz-Ss2i-pGYGl4x9bD93cnYKcSvsXaXyvyRawvgQs,9043
@@ -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.60.dist-info/licenses/LICENSE,sha256=eIubm_IlBHPYRQlLNZKbBNKhJUUP3JH0A2miZUhAVfI,1078
+iwa-0.0.62.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
@@ -178,6 +178,7 @@ tests/test_balance_service.py,sha256=wcuCOVszxPy8nPkldAVcEiygcOK3BuQt797fqAJvbp4
 tests/test_chain.py,sha256=VZoidSojWyt1y4mQdZdoZsjuuDZjLC6neTC-2SF_Q7I,13957
 tests/test_chain_interface.py,sha256=bgqGM8wJGZjc-BOX6i0K4sh06KCJl-6UAvrwl8x24lA,8324
 tests/test_chain_interface_coverage.py,sha256=fvrVvw8-DMwdsSFKQHUhpbfutrVRxnnTc-tjB7Bb-jo,3327
+tests/test_chainlist_enrichment.py,sha256=2iD5121SxSDpvQTkaoBXOW-cV-FD1NwkRvzlqRn2Ynk,12928
 tests/test_cli.py,sha256=Pl4RC2xp1omiJUnL3Dza6pCmIoO29LJ0vGw33_ZpT5c,3980
 tests/test_contract.py,sha256=tApHAxsfKGawYJWA9PhTNrOZUE0VVAq79ruIe3KxeWY,14412
 tests/test_db.py,sha256=dmbrupj0qlUeiiycZ2mzMFjf7HrDa6tcqMPY8zpiKIk,5710
@@ -202,7 +203,7 @@ tests/test_rpc_rate_limit.py,sha256=3P_Nd9voFmz-4r_Et-vw8W-Esbq5elSYmRBSOtJGx1Y,
 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_executor.py,sha256=V3ovBRY1lOuW5rm8rpm5Ns7jb-rgmHKHpz9pMTqz6c4,14448
+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_service_manager_integration.py,sha256=I_BLUzEKrVTyg_8jqsUK0oFD3aQVPCRJ7z0gY8P-j04,2354
@@ -211,7 +212,7 @@ tests/test_service_transaction.py,sha256=IeqYhmRD-pIXffBJrBQwfPx-qnfNEJs0iPM3eCb
 tests/test_staking_router.py,sha256=cnOtwWeQPu09kecVhlCf1WA4ONqs13OcQJhJCx2EOPY,3067
 tests/test_staking_simple.py,sha256=NHyZ1pcVQEJGFiGseC5m6Y9Y6FJGnRIFJUwhd1hAV9g,1138
 tests/test_tables.py,sha256=1KQHgxuizoOrRxpubDdnzk9iaU5Lwyp3bcWP_hZD5uU,2686
-tests/test_transaction_service.py,sha256=TXhIleUNOnp3DXi-RrKJ1Y_6dA6de5TQLOc9qndMHm4,5765
+tests/test_transaction_service.py,sha256=q2IQ6cJ6sZtzc_pVCM_dv0vW7LW2sONNrK5Pvrm63rU,12816
 tests/test_transfer_multisend.py,sha256=PErjNqNwN66TMh4oVa307re64Ucccg1LkXqB0KlkmsI,6677
 tests/test_transfer_native.py,sha256=cDbb4poV_veIw6eHpokrHe9yUndOjA6rQhrHd_IY3HQ,7445
 tests/test_transfer_security.py,sha256=gdpC6ybdXQbQgILbAQ0GqjWdwn9AJRNR3B_7TYg0NxI,3617
@@ -222,8 +223,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.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,,
+iwa-0.0.62.dist-info/METADATA,sha256=jnpILBgHX2FmSfLn2CXjYKhmkMp_Yr4rlOV5Ep_uknQ,7337
+iwa-0.0.62.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iwa-0.0.62.dist-info/entry_points.txt,sha256=nwB6kscrfA7M00pYmL2j-sBH6eF6h2ga9IK1BZxdiyQ,241
+iwa-0.0.62.dist-info/top_level.txt,sha256=kedS9cRUbm4JE2wYeabIXilhHjN8KCw0IGbqqqsw0Bs,16
+iwa-0.0.62.dist-info/RECORD,,