iwa 0.0.2__tar.gz → 0.0.11__tar.gz

{iwa-0.0.2/src/iwa.egg-info → iwa-0.0.11}/PKG-INFO

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

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

{iwa-0.0.2 → iwa-0.0.11}/src/iwa/core/chain/interface.py

@@ -1,5 +1,6 @@
 """ChainInterface class for blockchain interactions."""
 
+import threading
 import time
 from typing import Callable, Dict, Optional, Tuple, TypeVar, Union
 
@@ -45,6 +46,7 @@ class ChainInterface:
             )
 
         self._initial_block = 0
+        self._rotation_lock = threading.Lock()
         self._init_web3()
 
     @property
@@ -154,18 +156,6 @@ class ChainInterface:
         print("╚══════════════════════════════════════════════════╝")
         print("")
 
-    def _init_web3(self):
-        """Initialize Web3 with current RPC."""
-        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}))
-
-        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
-        # (isinstance check fails when RateLimitedWeb3 is mocked in tests)
-        if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
-            self.web3.set_backend(raw_web3)
-        else:
-            self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
-
     def _is_rate_limit_error(self, error: Exception) -> bool:
         """Check if error is a rate limit (429) error."""
         err_text = str(error).lower()
@@ -269,19 +259,36 @@ class ChainInterface:
 
     def rotate_rpc(self) -> bool:
         """Rotate to the next available RPC."""
-        if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
-            return False
+        with self._rotation_lock:
+            if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
+                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()
+
+            logger.info(
+                f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
+            )
+            return True
 
-        # Simple Round Robin rotation
-        # We don't check health here because the health check itself might consume rate limits
-        # or fail flakily. Better to just switch and try the operation.
-        self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
-        self._init_web3()
+    def _init_web3(self):
+        """Initialize Web3 with current RPC (thread-safe)."""
+        with self._rotation_lock:
+            self._init_web3_under_lock()
 
-        logger.info(
-            f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
-        )
-        return True
+    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}))
+
+        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
+        if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
+            self.web3.set_backend(raw_web3)
+        else:
+            self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
 
     def check_rpc_health(self) -> bool:
         """Check if the current RPC is healthy."""
@@ -358,15 +365,29 @@ class ChainInterface:
         except Exception:
             return address[:6] + "..." + address[-4:]
 
-    def get_token_decimals(self, address: EthereumAddress) -> int:
-        """Get token decimals for an address."""
-        try:
-            from iwa.core.contracts.erc20 import ERC20Contract
+    def get_token_decimals(self, address: EthereumAddress, fallback_to_18: bool = True) -> Optional[int]:
+        """Get token decimals for an address.
 
-            erc20 = ERC20Contract(address, self.chain.name.lower())
-            return erc20.decimals if erc20.decimals is not None else 18
+        Args:
+            address: Token contract address.
+            fallback_to_18: If True, return 18 on error (default).
+                           If False, return None on error (useful for detecting NFTs).
+
+        Returns:
+            Decimals as int, or None if error and fallback_to_18 is False.
+
+        """
+        try:
+            # Call decimals() directly without with_retry to avoid error logging
+            contract = self.web3.eth.contract(
+                address=self.web3.to_checksum_address(address),
+                abi=[{"constant": True, "inputs": [], "name": "decimals", "outputs": [{"type": "uint8"}], "type": "function"}]
+            )
+            return contract.functions.decimals().call()
         except Exception:
-            return 18
+            if fallback_to_18:
+                return 18
+            return None
 
     def get_native_balance_wei(self, address: EthereumAddress):
         """Get the native balance in wei"""

{iwa-0.0.2 → iwa-0.0.11}/src/iwa/core/chain/models.py

@@ -78,13 +78,11 @@ class Gnosis(SupportedChain):
         if not self.rpcs and secrets.gnosis_rpc:
             self.rpcs = secrets.gnosis_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -107,13 +105,11 @@ class Ethereum(SupportedChain):
         if not self.rpcs and secrets.ethereum_rpc:
             self.rpcs = secrets.ethereum_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -136,13 +132,11 @@ class Base(SupportedChain):
         if not self.rpcs and secrets.base_rpc:
             self.rpcs = secrets.base_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 

{iwa-0.0.2 → iwa-0.0.11}/src/iwa/core/contracts/contract.py

@@ -190,10 +190,16 @@ class ContractInstance:
             Exception: If the call fails, with decoded error information.
 
         """
-        method = getattr(self.contract.functions, method_name)
         try:
+
+            def do_call():
+                # Re-evaluate self.contract on each retry to get current provider
+                # This is critical for RPC rotation to work correctly
+                method = getattr(self.contract.functions, method_name)
+                return method(*args).call()
+
             return self.chain_interface.with_retry(
-                lambda: method(*args).call(),
+                do_call,
                 operation_name=f"call {method_name} on {self.name}",
             )
         except Exception as e:

{iwa-0.0.2 → iwa-0.0.11}/src/iwa/core/pricing.py

@@ -9,17 +9,19 @@ from loguru import logger
 
 from iwa.core.secrets import secrets
 
+# Global cache shared across all PriceService instances
+_PRICE_CACHE: Dict[str, Dict] = {}
+_CACHE_TTL = timedelta(minutes=30)
+
 
 class PriceService:
     """Service to fetch token prices from CoinGecko."""
 
     BASE_URL = "https://api.coingecko.com/api/v3"
 
-    def __init__(self, cache_ttl_minutes: int = 5):
+    def __init__(self):
         """Initialize PriceService."""
         self.secrets = secrets
-        self.cache: Dict[str, Dict] = {}  # {id_currency: {"price": float, "timestamp": datetime}}
-        self.cache_ttl = timedelta(minutes=cache_ttl_minutes)
         self.api_key = (
             self.secrets.coingecko_api_key.get_secret_value()
             if self.secrets.coingecko_api_key
@@ -39,15 +41,15 @@ class PriceService:
         """
         cache_key = f"{token_id}_{vs_currency}"
 
-        # Check cache
-        if cache_key in self.cache:
-            entry = self.cache[cache_key]
-            if datetime.now() - entry["timestamp"] < self.cache_ttl:
+        # Check global cache
+        if cache_key in _PRICE_CACHE:
+            entry = _PRICE_CACHE[cache_key]
+            if datetime.now() - entry["timestamp"] < _CACHE_TTL:
                 return entry["price"]
 
         price = self._fetch_price_from_api(token_id, vs_currency)
         if price is not None:
-            self.cache[cache_key] = {"price": price, "timestamp": datetime.now()}
+            _PRICE_CACHE[cache_key] = {"price": price, "timestamp": datetime.now()}
         return price
 
     def _fetch_price_from_api(self, token_id: str, vs_currency: str) -> Optional[float]:

{iwa-0.0.2 → iwa-0.0.11}/src/iwa/core/services/safe.py

@@ -11,7 +11,6 @@ from safe_eth.safe.safe_tx import SafeTx
 from iwa.core.constants import ZERO_ADDRESS
 from iwa.core.db import log_transaction
 from iwa.core.models import StoredSafeAccount
-from iwa.core.secrets import secrets
 from iwa.core.utils import (
     get_safe_master_copy_address,
     get_safe_proxy_factory_address,
@@ -99,8 +98,11 @@ class SafeService:
         return owner_addresses
 
     def _get_ethereum_client(self, chain_name: str) -> EthereumClient:
-        rpc_secret = getattr(secrets, f"{chain_name}_rpc")
-        return EthereumClient(rpc_secret.get_secret_value())
+        from iwa.core.chain import ChainInterfaces
+
+        # Use ChainInterface which has proper RPC rotation and parsing
+        chain_interface = ChainInterfaces().get(chain_name)
+        return EthereumClient(chain_interface.chain.rpc)
 
     def _deploy_safe_contract(
         self,
@@ -141,7 +143,7 @@ class SafeService:
                 gas=5_000_000,
                 gas_price=gas_price,
             )
-            return tx_sent.contract_address, tx_sent.tx_hash.hex()
+            return tx_sent.contract_address, f"0x{tx_sent.tx_hash.hex()}"
 
         else:
             # Standard random salt via Safe.create
@@ -153,7 +155,7 @@ class SafeService:
                 threshold=threshold,
                 proxy_factory_address=proxy_factory_address,
             )
-            return create_tx.contract_address, create_tx.tx_hash.hex()
+            return create_tx.contract_address, f"0x{create_tx.tx_hash.hex()}"
 
     def _log_safe_deployment(
         self,
@@ -248,8 +250,11 @@ class SafeService:
                 continue
 
             for chain in account.chains:
-                rpc_secret = getattr(secrets, f"{chain}_rpc")
-                ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+                from iwa.core.chain import ChainInterfaces
+
+                # Use ChainInterface which has proper RPC rotation and parsing
+                chain_interface = ChainInterfaces().get(chain)
+                ethereum_client = EthereumClient(chain_interface.chain.rpc)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 
@@ -304,7 +309,7 @@ class SafeService:
             # Execute using the first signer
             safe_tx.execute(signer_keys[0])
 
-            return safe_tx.tx_hash.hex()
+            return f"0x{safe_tx.tx_hash.hex()}"
         finally:
             # SECURITY: Overwrite keys with zeros before clearing (best effort)
             for i in range(len(signer_keys)):