iwa 0.0.33__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
 
@@ -34,9 +36,11 @@ class ChainInterface:
             chain: SupportedChain = getattr(SupportedChains(), chain.lower())
 
         self.chain = chain
-        self._rate_limiter = get_rate_limiter(chain.name)
+        # Enforce strict 1.0 RPS limit to prevent synchronization issues
+        self._rate_limiter = get_rate_limiter(chain.name, rate=1.0, burst=1)
         self._current_rpc_index = 0
         self._rpc_failure_counts: Dict[int, int] = {}
+        self._last_rotation_time = 0.0  # Monotonic timestamp of last rotation
 
         if self.chain.rpc and self.chain.rpc.startswith("http://"):
             logger.warning(
@@ -46,6 +50,7 @@ class ChainInterface:
 
         self._initial_block = 0
         self._rotation_lock = threading.Lock()
+        self._session = requests.Session()
         self._init_web3()
 
     @property
@@ -213,12 +218,24 @@ class ChainInterface:
         ]
         return any(signal in err_text for signal in server_error_signals)
 
+    def _is_gas_error(self, error: Exception) -> bool:
+        """Check if error is related to gas limits or fees."""
+        err_text = str(error).lower()
+        gas_signals = [
+            "intrinsic gas too low",
+            "feetoolow",
+            "gas limit",
+            "underpriced",
+        ]
+        return any(signal in err_text for signal in gas_signals)
+
     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]] = {
             "is_rate_limit": self._is_rate_limit_error(error),
             "is_connection_error": self._is_connection_error(error),
             "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),
             "rotated": False,
             "should_retry": False,
@@ -242,9 +259,11 @@ class ChainInterface:
 
         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)
             logger.warning(
                 f"RPC {error_type} error on {self.chain.name} "
-                f"(RPC #{self._current_rpc_index}): {error}"
+                f"(current RPC #{self._current_rpc_index}): {error_msg}"
             )
 
             if self.rotate_rpc():
@@ -253,14 +272,22 @@ class ChainInterface:
                 logger.info(f"Rotated to RPC #{self._current_rpc_index} for {self.chain.name}")
             else:
                 if result["is_rate_limit"]:
-                    self._rate_limiter.trigger_backoff(seconds=5.0)
+                    # 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.warning("No other RPCs available, triggered backoff")
+                    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}")
             result["should_retry"] = True
 
+        elif result["is_gas_error"]:
+            logger.warning(f"Gas/Fee error detected: {error}. Allowing retry for adjustment.")
+            result["should_retry"] = True
+
         return result
 
     def rotate_rpc(self) -> bool:
@@ -269,11 +296,22 @@ class ChainInterface:
             if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
                 return False
 
+            # Cooldown: prevent cascade rotations from in-flight requests
+            now = time.monotonic()
+            elapsed = now - self._last_rotation_time
+            if elapsed < self.ROTATION_COOLDOWN_SECONDS:
+                logger.debug(
+                    f"RPC rotation skipped for {self.chain.name} (cooldown active, "
+                    f"{self.ROTATION_COOLDOWN_SECONDS - elapsed:.1f}s remaining)"
+                )
+                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.
             self._init_web3_under_lock()
+            self._last_rotation_time = now
 
             logger.info(
                 f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
@@ -288,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"):
@@ -371,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:
@@ -388,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:
@@ -423,18 +475,85 @@ class ChainInterface:
             return 500_000
 
     def calculate_transaction_params(
-        self, built_method: Callable, tx_params: Dict[str, Union[str, int]]
+        self, built_method: Optional[Callable], tx_params: Dict[str, Union[str, int]]
     ) -> Dict[str, Union[str, int]]:
-        """Calculate transaction parameters for a contract function call."""
+        """Calculate transaction parameters for a contract function call or native transfer."""
+        # Baseline parameters
         params = {
             "from": tx_params["from"],
             "value": tx_params.get("value", 0),
             "nonce": self.web3.eth.get_transaction_count(tx_params["from"]),
-            "gas": self.estimate_gas(built_method, tx_params),
-            "gasPrice": self.web3.eth.gas_price,
         }
+
+        # Add 'to' only for native transfers (built_method is None)
+        # 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
+
+        # Determine gas
+        if built_method:
+            # Contract function call
+            params["gas"] = self.estimate_gas(built_method, tx_params)
+        elif "gas" in tx_params:
+            # Manual gas override
+            params["gas"] = tx_params["gas"]
+        else:
+            # 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"]}
+                # Remove None 'to' for contract creation simulation if needed, but usually send() has to
+                if not est_params["to"]:
+                    est_params.pop("to")
+
+                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})"
+                )
+            except Exception as e:
+                logger.debug(f"[GAS] Native estimation failed, fallback to 21000: {e}")
+                params["gas"] = 21_000
+
+        # Add EIP-1559 or Legacy fees
+        params.update(self.get_suggested_fees())
         return params
 
+    def get_suggested_fees(self) -> Dict[str, int]:
+        """Calculate suggested fees for a transaction (EIP-1559 or legacy)."""
+        try:
+            # Check for EIP-1559 support
+            latest_block = self.web3.eth.get_block("latest")
+            base_fee = latest_block.get("baseFeePerGas")
+
+            if base_fee is not None:
+                # EIP-1559 logic
+                max_priority_fee = int(self.web3.eth.max_priority_fee)
+
+                # Gnosis specific: ensure min priority fee (critical for validation)
+                if self.chain.name.lower() == "gnosis":
+                    if max_priority_fee < 1:
+                        max_priority_fee = 1  # Network minimum is 1 wei
+
+                # Global minimum for EIP-1559
+                if max_priority_fee < 1:
+                    max_priority_fee = 1
+
+                # 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}
+        except Exception as e:
+            logger.debug(f"Failed to calculate EIP-1559 fees: {e}, falling back to legacy")
+
+        # Legacy fallback
+        return {"gasPrice": self.web3.eth.gas_price}
+
     def wait_for_no_pending_tx(
         self, from_address: EthereumAddress, max_wait_seconds: int = 60, poll_interval: float = 2.0
     ):

iwa/core/chain/models.py

@@ -26,6 +26,9 @@ class SupportedChain(BaseModel):
 
     def get_token_address(self, token_address_or_name: str) -> Optional[EthereumAddress]:
         """Get token address"""
+        if not token_address_or_name:
+            return None
+
         try:
             address = EthereumAddress(token_address_or_name)
         except Exception:
@@ -35,9 +38,18 @@ class SupportedChain(BaseModel):
             return address
 
         if address is None:
-            return self.tokens.get(token_address_or_name, None)
-
-        return None
+            # Try direct lookup
+            token_addr = self.tokens.get(token_address_or_name, None)
+            if token_addr:
+                return token_addr
+
+            # Try case-insensitive lookup
+            target_lower = token_address_or_name.lower()
+            for name, addr in self.tokens.items():
+                if name.lower() == target_lower:
+                    return addr
+
+            return None
 
     def get_token_name(self, token_address: str) -> Optional[str]:
         """Get token name from address."""

iwa/core/chain/rate_limiter.py

@@ -108,12 +108,11 @@ def get_rate_limiter(chain_name: str, rate: float = None, burst: int = None) ->
 class RateLimitedEth:
     """Wrapper around web3.eth that applies rate limiting transparently."""
 
-    RPC_METHODS = {
+    READ_METHODS = {
         "get_balance",
         "get_code",
         "get_transaction_count",
         "estimate_gas",
-        "send_raw_transaction",
         "wait_for_transaction_receipt",
         "get_block",
         "get_transaction",
@@ -122,6 +121,16 @@ class RateLimitedEth:
         "get_logs",
     }
 
+    WRITE_METHODS = {
+        "send_raw_transaction",
+    }
+
+    # Helper sets for efficient lookup
+    RPC_METHODS = READ_METHODS | WRITE_METHODS
+
+    DEFAULT_READ_RETRIES = 3
+    DEFAULT_READ_RETRY_DELAY = 0.5
+
     def __init__(self, web3_eth, rate_limiter: RPCRateLimiter, chain_interface: "ChainInterface"):
         """Initialize RateLimitedEth wrapper."""
         object.__setattr__(self, "_eth", web3_eth)
@@ -133,7 +142,7 @@ class RateLimitedEth:
         attr = getattr(self._eth, name)
 
         if name in self.RPC_METHODS and callable(attr):
-            return self._wrap_with_rate_limit(attr, name)
+            return self._wrap_with_retry(attr, name)
 
         return attr
 
@@ -151,23 +160,50 @@ class RateLimitedEth:
         else:
             delattr(self._eth, name)
 
-    def _wrap_with_rate_limit(self, method, method_name):
-        """Wrap a method with rate limiting.
+    @property
+    def block_number(self):
+        """Get block number with retry."""
+        return self._execute_with_retry(lambda: self._eth.block_number, "block_number")
 
-        Note: Error handling (rotation, retry) is NOT done here.
-        It is the responsibility of `ChainInterface.with_retry()` to handle
-        errors and rotate RPCs as needed. This wrapper only ensures
-        rate limiting.
-        """
+    @property
+    def gas_price(self):
+        """Get gas price with retry."""
+        return self._execute_with_retry(lambda: self._eth.gas_price, "gas_price")
+
+    def _wrap_with_retry(self, method, method_name):
+        """Wrap method with rate limiting and retry for reads."""
 
         def wrapper(*args, **kwargs):
             if not self._rate_limiter.acquire(timeout=30.0):
-                raise TimeoutError(f"Rate limit timeout waiting for {method_name}")
+                raise TimeoutError(f"Rate limit timeout for {method_name}")
+
+            # Writes: no auto-retry (handled by caller or not safe)
+            if method_name in self.WRITE_METHODS:
+                return method(*args, **kwargs)
 
-            return method(*args, **kwargs)
+            # Reads: with retry
+            return self._execute_with_retry(method, method_name, *args, **kwargs)
 
         return wrapper
 
+    def _execute_with_retry(self, method, method_name, *args, **kwargs):
+        """Execute read operation with retry logic."""
+        for attempt in range(self.DEFAULT_READ_RETRIES + 1):
+            try:
+                return method(*args, **kwargs)
+            except Exception as e:
+                # Use chain interface to handle error (logging, rotation, etc.)
+                result = self._chain_interface._handle_rpc_error(e)
+
+                if not result["should_retry"] or attempt >= self.DEFAULT_READ_RETRIES:
+                    raise
+
+                delay = self.DEFAULT_READ_RETRY_DELAY * (2**attempt)
+                logger.debug(
+                    f"{method_name} attempt {attempt + 1} failed, retrying in {delay:.1f}s..."
+                )
+                time.sleep(delay)
+
 
 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")
@@ -40,7 +43,7 @@ def account_create(
     """Create a new wallet account"""
     key_storage = KeyStorage()
     try:
-        key_storage.create_account(tag)
+        key_storage.generate_new_account(tag)
     except ValueError as e:
         typer.echo(f"Error: {e}")
         raise typer.Exit(code=1) from e

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

@@ -7,13 +7,21 @@ direct HTTP API calls, avoiding heavy dependencies like open-aea.
 import hashlib
 import json
 import uuid
-from typing import Any, Dict, Optional, Tuple
+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 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:
     """Compute CIDv1 hex representation from raw data.
@@ -56,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)
@@ -83,7 +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
+    global _SYNC_SESSION
+
+    if _SYNC_SESSION is None:
+        _SYNC_SESSION = create_retry_session()
 
     url = api_url or Config().core.ipfs_api_url
     endpoint = f"{url}/api/v0/add"
@@ -92,7 +106,7 @@ def push_to_ipfs_sync(
 
     files = {"file": ("data", data, "application/octet-stream")}
 
-    response = requests.post(endpoint, files=files, params=params, timeout=60)
+    response = _SYNC_SESSION.post(endpoint, files=files, params=params, timeout=60)
     response.raise_for_status()
     result = response.json()