iwa 0.0.19__tar.gz → 0.0.21__tar.gz

{iwa-0.0.19/src/iwa.egg-info → iwa-0.0.21}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.19"
+version = "0.0.21"
 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.19"
+target-version = "0.0.21"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/core/chain/interface.py

@@ -48,10 +48,17 @@ class ChainInterface:
         self._rotation_lock = threading.Lock()
         self._init_web3()
 
+    @property
+    def current_rpc(self) -> str:
+        """Get the current active RPC URL."""
+        if not self.chain.rpcs:
+            return ""
+        return self.chain.rpcs[self._current_rpc_index]
+
     @property
     def is_tenderly(self) -> bool:
         """Check if connected to Tenderly vNet."""
-        rpc = self.chain.rpc or ""
+        rpc = self.current_rpc or ""
         return "tenderly" in rpc.lower() or "virtual" in rpc.lower()
 
     def init_block_tracking(self):

iwa-0.0.21/src/iwa/core/chainlist.py

@@ -0,0 +1,116 @@
+"""Module for fetching and parsing RPCs from Chainlist.org."""
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from iwa.core.constants import CACHE_DIR
+
+
+@dataclass
+class RPCNode:
+    """Represents a single RPC node with its properties."""
+
+    url: str
+    is_working: bool
+    privacy: Optional[str] = None
+    tracking: Optional[str] = None
+
+    @property
+    def is_tracking(self) -> bool:
+        """Returns True if the RPC is known to track user data."""
+        return self.privacy == "privacy" or self.tracking in ("limited", "yes")
+
+
+class ChainlistRPC:
+    """Fetcher and parser for Chainlist RPC data."""
+
+    URL = "https://chainlist.org/rpcs.json"
+    CACHE_PATH = CACHE_DIR / "chainlist_rpcs.json"
+    CACHE_TTL = 86400  # 24 hours
+
+    def __init__(self) -> None:
+        """Initialize the ChainlistRPC instance."""
+        self._data: List[Dict[str, Any]] = []
+
+    def fetch_data(self, force_refresh: bool = False) -> None:
+        """Fetches the RPC data from Chainlist with local caching."""
+        # 1. Try local cache first unless force_refresh is requested
+        if not force_refresh and self.CACHE_PATH.exists():
+            try:
+                mtime = self.CACHE_PATH.stat().st_mtime
+                if time.time() - mtime < self.CACHE_TTL:
+                    with self.CACHE_PATH.open("r") as f:
+                        self._data = json.load(f)
+                    if self._data:
+                        return
+            except Exception as e:
+                print(f"Error reading Chainlist cache: {e}")
+
+        # 2. Fetch from remote
+        try:
+            response = requests.get(self.URL, timeout=10)
+            response.raise_for_status()
+            self._data = response.json()
+
+            # 3. Update local cache
+            if self._data:
+                self.CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+                with self.CACHE_PATH.open("w") as f:
+                    json.dump(self._data, f)
+        except requests.RequestException as e:
+            print(f"Error fetching Chainlist data from {self.URL}: {e}")
+            # Fallback to expired cache if available
+            if not self._data and self.CACHE_PATH.exists():
+                try:
+                    with self.CACHE_PATH.open("r") as f:
+                        self._data = json.load(f)
+                except Exception:
+                    pass
+            if not self._data:
+                self._data = []
+
+    def get_chain_data(self, chain_id: int) -> Optional[Dict[str, Any]]:
+        """Returns the raw chain data for a specific chain ID."""
+        if not self._data:
+            self.fetch_data()
+
+        for entry in self._data:
+            if entry.get('chainId') == chain_id:
+                return entry
+        return None
+
+    def get_rpcs(self, chain_id: int) -> List[RPCNode]:
+        """Returns a list of RPCNode objects for a parsed and cleaner view."""
+        chain_data = self.get_chain_data(chain_id)
+        if not chain_data:
+            return []
+
+        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')
+            ))
+        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
+            if node.url.startswith("https://") or node.url.startswith("http://")
+        ]
+
+    def get_wss_rpcs(self, chain_id: int) -> List[str]:
+        """Returns a list of WSS RPC URLs for the given chain."""
+        rpcs = self.get_rpcs(chain_id)
+        return [
+            node.url for node in rpcs
+            if node.url.startswith("wss://") or node.url.startswith("ws://")
+        ]

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/core/constants.py

@@ -8,6 +8,7 @@ PROJECT_ROOT = Path(__file__).parent.parent.parent.parent
 
 # Data directory for runtime files
 DATA_DIR = Path("data")
+CACHE_DIR = DATA_DIR / "cache"
 
 # secrets.env is at project root (NOT in data/)
 SECRETS_PATH = Path("secrets.env")

iwa-0.0.21/src/iwa/core/contracts/cache.py

@@ -0,0 +1,131 @@
+"""Contract instance cache to reduce RPC calls during instantiation."""
+
+import os
+import time
+from threading import Lock
+from typing import Any, Dict, Optional, Type, TypeVar
+
+from loguru import logger
+
+T = TypeVar("T")
+
+
+class ContractCache:
+    """Singleton cache for contract instances.
+
+    Stores contract instances keyed by (class, address, chain) to prevent
+    redundant instantiation and the associated RPC calls.
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls) -> "ContractCache":
+        """Ensure singleton instance."""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(ContractCache, cls).__new__(cls)
+                cls._instance._contracts: Dict[str, Any] = {}
+                cls._instance._creation_times: Dict[str, float] = {}
+
+                # Default TTL: 1 hour, configurable via env var
+                env_ttl = os.environ.get("IWA_CONTRACT_CACHE_TTL")
+                try:
+                    cls._instance.ttl = int(env_ttl) if env_ttl else 3600
+                except ValueError:
+                    cls._instance.ttl = 3600
+                    logger.warning(f"Invalid IWA_CONTRACT_CACHE_TTL value: {env_ttl}. Using 3600.")
+
+        return cls._instance
+
+    def get_contract(
+        self,
+        contract_cls: Type[T],
+        address: str,
+        chain_name: str,
+        ttl: Optional[int] = None,
+    ) -> T:
+        """Get a cached contract instance or create a new one.
+
+        Args:
+            contract_cls: The contract class to instantiate.
+            address: The contract address.
+            chain_name: The chain name.
+            ttl: Optional TTL override in seconds.
+
+        Returns:
+            The contract instance (cached or new).
+
+        """
+        if not address:
+            raise ValueError("Address is required for contract caching")
+
+        key = self._make_key(contract_cls, address, chain_name)
+        now = time.time()
+        expiry = (ttl if ttl is not None else self.ttl)
+
+        with self._lock:
+            # Check if cached and valid
+            if key in self._contracts:
+                created_at = self._creation_times.get(key, 0)
+                if now - created_at < expiry:
+                    return self._contracts[key]
+                else:
+                    logger.debug(f"Contract cache expired for {key}")
+                    del self._contracts[key]
+                    del self._creation_times[key]
+
+            # Create new instance
+            logger.debug(f"Creating new cached contract instance for {key}")
+            instance = contract_cls(address, chain_name=chain_name)
+            self._contracts[key] = instance
+            self._creation_times[key] = now
+            return instance
+
+    def get_if_cached(
+        self,
+        contract_cls: Type[T],
+        address: str,
+        chain_name: str,
+    ) -> Optional[T]:
+        """Get a cached contract instance if it exists and is valid.
+
+        Does NOT create a new instance if not found.
+        """
+        if not address:
+            return None
+
+        key = self._make_key(contract_cls, address, chain_name)
+        now = time.time()
+
+        with self._lock:
+            if key in self._contracts:
+                # Check TTL
+                created_at = self._creation_times.get(key, 0)
+                if now - created_at < self.ttl:
+                    return self._contracts[key]
+                else:
+                    # Expired, clean up
+                    del self._contracts[key]
+                    del self._creation_times[key]
+        return None
+
+    def _make_key(self, contract_cls: Type, address: str, chain_name: str) -> str:
+        """Create a unique cache key."""
+        return f"{contract_cls.__name__}:{chain_name.lower()}:{address.lower()}"
+
+    def clear(self) -> None:
+        """Clear all cached contracts."""
+        with self._lock:
+            self._contracts.clear()
+            self._creation_times.clear()
+            logger.debug("Contract cache cleared")
+
+    def invalidate(self, contract_cls: Type, address: str, chain_name: str) -> None:
+        """Invalidate a specific contract in the cache."""
+        key = self._make_key(contract_cls, address, chain_name)
+        with self._lock:
+            if key in self._contracts:
+                del self._contracts[key]
+                del self._creation_times[key]
+                logger.debug(f"Invalidated cache for {key}")

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/core/contracts/contract.py

@@ -11,6 +11,7 @@ from web3.contract import Contract
 from web3.exceptions import ContractCustomError
 
 from iwa.core.chain import ChainInterfaces
+from iwa.core.rpc_monitor import RPCMonitor
 from iwa.core.utils import configure_logger
 
 logger = configure_logger()
@@ -221,6 +222,8 @@ class ContractInstance:
                 # 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)
+                # Count the RPC call
+                RPCMonitor().increment(f"{self.name}.{method_name}")
                 return method(*args).call()
 
             return self.chain_interface.with_retry(
@@ -277,6 +280,10 @@ class ContractInstance:
 
         try:
             tx_params = self.chain_interface.calculate_transaction_params(built_method, tx_params)
+
+            # Count the estimateGas/buildTransaction RPC calls
+            RPCMonitor().increment(f"{self.name}.{method_name}.estimate_gas")
+
             transaction = built_method.build_transaction(tx_params)
             return transaction
 

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/core/monitor.py

@@ -24,7 +24,7 @@ class EventMonitor:
         self.chain_interface = ChainInterfaces().get(chain_name)
         self.web3 = self.chain_interface.web3
         self.running = False
-        if self.chain_interface.chain.rpc:
+        if self.chain_interface.current_rpc:
             try:
                 self.last_checked_block = self.web3.eth.block_number
             except Exception:
@@ -39,7 +39,7 @@ class EventMonitor:
             f"Starting EventMonitor for {len(self.addresses)} addresses on {self.chain_interface.chain.name}"
         )
 
-        if not self.chain_interface.chain.rpc:
+        if not self.chain_interface.current_rpc:
             logger.error(
                 f"Cannot start EventMonitor: No RPC URL found for chain {self.chain_interface.chain.name}"
             )

iwa-0.0.21/src/iwa/core/rpc_monitor.py

@@ -0,0 +1,60 @@
+"""RPC Monitor for tracking API usage."""
+import threading
+from collections import defaultdict
+from typing import Dict
+
+from iwa.core.utils import configure_logger
+
+logger = configure_logger()
+
+
+class RPCMonitor:
+    """Singleton monitor for tracking RPC usage."""
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        """Create singleton instance."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(RPCMonitor, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        """Initialize monitor."""
+        if self._initialized:
+            return
+        self._counts: Dict[str, int] = defaultdict(int)
+        self._lock = threading.Lock()
+        self._initialized = True
+
+    def increment(self, metric_name: str, count: int = 1):
+        """Increment a metric counter."""
+        with self._lock:
+            self._counts[metric_name] += count
+
+    def get_counts(self) -> Dict[str, int]:
+        """Get a copy of current counts."""
+        with self._lock:
+            return dict(self._counts)
+
+    def log_stats(self):
+        """Log current statistics."""
+        stats = self.get_counts()
+        if not stats:
+            return
+
+        logger.info("RPC Stats Summary:")
+        total = 0
+        for k, v in sorted(stats.items()):
+            logger.info(f"  {k}: {v}")
+            total += v
+        logger.info(f"  TOTAL: {total}")
+
+    def clear(self):
+        """Clear all counters."""
+        with self._lock:
+            self._counts.clear()

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/core/services/safe.py

@@ -102,7 +102,7 @@ class SafeService:
 
         # Use ChainInterface which has proper RPC rotation and parsing
         chain_interface = ChainInterfaces().get(chain_name)
-        return EthereumClient(chain_interface.chain.rpc)
+        return EthereumClient(chain_interface.current_rpc)
 
     def _deploy_safe_contract(
         self,
@@ -254,7 +254,7 @@ class SafeService:
 
                 # Use ChainInterface which has proper RPC rotation and parsing
                 chain_interface = ChainInterfaces().get(chain)
-                ethereum_client = EthereumClient(chain_interface.chain.rpc)
+                ethereum_client = EthereumClient(chain_interface.current_rpc)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/plugins/gnosis/safe.py

@@ -30,7 +30,7 @@ class SafeMultisig:
         from iwa.core.chain import ChainInterfaces
 
         chain_interface = ChainInterfaces().get(chain_name.lower())
-        ethereum_client = EthereumClient(chain_interface.chain.rpc)
+        ethereum_client = EthereumClient(chain_interface.current_rpc)
         self.multisig = Safe(safe_account.address, ethereum_client)
         self.ethereum_client = ethereum_client
 

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/plugins/gnosis/tests/test_safe.py

@@ -42,7 +42,7 @@ def test_init(safe_account, mock_settings, mock_safe_eth):
     """Test initialization."""
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         ms = SafeMultisig(safe_account, "gnosis")
         assert ms.multisig is not None
         mock_safe_eth[0].assert_called_with("http://rpc")  # EthereumClient init

{iwa-0.0.19 → iwa-0.0.21}/src/iwa/plugins/olas/contracts/activity_checker.py

@@ -8,7 +8,7 @@ The liveness check (isRatioPass) verifies that the service is making enough mech
 requests relative to the time elapsed since the last checkpoint.
 """
 
-from typing import Tuple
+from typing import Optional, Tuple
 
 from iwa.core.constants import DEFAULT_MECH_CONTRACT_ADDRESS
 from iwa.core.types import EthereumAddress
@@ -43,27 +43,11 @@ class ActivityCheckerContract(ContractInstance):
         """
         super().__init__(address, chain_name=chain_name)
 
-        # Check for marketplace-aware checker
-        try:
-            mech_mp_function = getattr(self.contract.functions, "mechMarketplace", None)
-            self.mech_marketplace = mech_mp_function().call() if mech_mp_function else None
-        except Exception:
-            self.mech_marketplace = None
-
-        # Get the mech address this checker tracks (legacy or priority mech)
-        try:
-            agent_mech_function = getattr(self.contract.functions, "agentMech", None)
-            self.agent_mech = (
-                agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
-            )
-        except Exception:
-            self.agent_mech = DEFAULT_MECH_CONTRACT_ADDRESS
-
-        # Get liveness ratio (requests per second * 1e18)
-        try:
-            self.liveness_ratio = self.contract.functions.livenessRatio().call()
-        except Exception:
-            self.liveness_ratio = 0
+        # Cache for lazy loading
+        self._mech_marketplace: Optional[EthereumAddress] = None
+        self._agent_mech: Optional[EthereumAddress] = None
+        self._liveness_ratio: Optional[int] = None
+
 
     def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
         """Get the nonces for a multisig address.
@@ -80,6 +64,41 @@ class ActivityCheckerContract(ContractInstance):
         nonces = self.contract.functions.getMultisigNonces(multisig).call()
         return (nonces[0], nonces[1])
 
+
+    @property
+    def mech_marketplace(self) -> Optional[EthereumAddress]:
+        """Get the mech marketplace address."""
+        if self._mech_marketplace is None:
+            try:
+                mech_mp_function = getattr(self.contract.functions, "mechMarketplace", None)
+                self._mech_marketplace = mech_mp_function().call() if mech_mp_function else None
+            except Exception:
+                self._mech_marketplace = None
+        return self._mech_marketplace
+
+    @property
+    def agent_mech(self) -> EthereumAddress:
+        """Get the agent mech address."""
+        if self._agent_mech is None:
+            try:
+                agent_mech_function = getattr(self.contract.functions, "agentMech", None)
+                self._agent_mech = (
+                    agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
+                )
+            except Exception:
+                self._agent_mech = DEFAULT_MECH_CONTRACT_ADDRESS
+        return self._agent_mech
+
+    @property
+    def liveness_ratio(self) -> int:
+        """Get the liveness ratio."""
+        if self._liveness_ratio is None:
+            try:
+                self._liveness_ratio = self.contract.functions.livenessRatio().call()
+            except Exception:
+                self._liveness_ratio = 0
+        return self._liveness_ratio
+
     def is_ratio_pass(
         self,
         current_nonces: Tuple[int, int],
@@ -101,6 +120,25 @@ class ActivityCheckerContract(ContractInstance):
             True if liveness requirements are met.
 
         """
-        return self.contract.functions.isRatioPass(
-            list(current_nonces), list(last_nonces), ts_diff
-        ).call()
+        # Optimized implementation to avoid RPC call
+        current_safe, current_requests = current_nonces
+        last_safe, last_requests = last_nonces
+
+        diff_safe = current_safe - last_safe
+        diff_requests = current_requests - last_requests
+
+        # 1. Check if requests exceed transactions (impossible in valid operation)
+        # Also check for negative diffs (data corruption/stale data edge case)
+        if diff_requests > diff_safe or diff_requests < 0 or diff_safe < 0:
+            return False
+
+        # 2. Check time difference validity
+        if ts_diff == 0:
+            return False
+
+        # 3. Check ratio
+        # ratio = (diffRequests * 1e18) / ts_diff >= livenessRatio
+        # We use integer arithmetic as per Solidity
+        ratio = (diff_requests * 10**18) // ts_diff
+
+        return ratio >= self.liveness_ratio