iwa 0.0.19__tar.gz → 0.0.20__tar.gz

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

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

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

iwa-0.0.20/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.20}/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.20/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.20}/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.20/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.20}/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

{iwa-0.0.19 → iwa-0.0.20}/src/iwa/plugins/olas/contracts/staking.py

@@ -79,22 +79,9 @@ class StakingContract(ContractInstance):
         self.chain_name = chain_name
         self._contract_params_cache: Dict[str, int] = {}
 
-        # Get activity checker from the staking contract
-        activity_checker_address = self.call("activityChecker")
-        self.activity_checker = ActivityCheckerContract(
-            activity_checker_address, chain_name=chain_name
-        )
-        self.activity_checker_address = activity_checker_address
-
-        # Cache contract parameters
-        self.available_rewards = self.call("availableRewards")
-        self.balance = self.call("balance")
-        self.liveness_period = self.call("livenessPeriod")
-        self.rewards_per_second = self.call("rewardsPerSecond")
-        self.max_num_services = self.call("maxNumServices")
-        self.min_staking_deposit = self.call("minStakingDeposit")
-        self.min_staking_duration_hours = self.call("minStakingDuration") / 3600
-        self.staking_token_address = self.call("stakingToken")
+        self._activity_checker: Optional[ActivityCheckerContract] = None
+        self._activity_checker_address: Optional[EthereumAddress] = None
+
 
     def get_requirements(self) -> Dict[str, Union[str, int]]:
         """Get the contract requirements for token and deposits.
@@ -193,10 +180,16 @@ class StakingContract(ContractInstance):
         remaining_seconds = (epoch_end - datetime.now(timezone.utc)).total_seconds()
 
         # Check liveness ratio using activity checker
+        # logic: use the latest of (service_start_time, global_checkpoint_time)
+        # If service started AFTER global checkpoint, use service_start_time.
+        # If service was already running, use global_checkpoint_time.
+        global_ts_checkpoint = self.ts_checkpoint()
+        effective_ts_start = max(ts_start, global_ts_checkpoint)
+
         liveness_passed = self.is_liveness_ratio_passed(
             current_nonces=current_nonces,
             last_nonces=(last_safe_nonce, last_mech_requests),
-            ts_start=ts_start,
+            ts_start=effective_ts_start,
         )
 
         return {
@@ -223,8 +216,36 @@ class StakingContract(ContractInstance):
         return StakingState(self.call("getStakingState", service_id))
 
     def ts_checkpoint(self) -> int:
-        """Get the timestamp of the last checkpoint."""
-        return self.call("tsCheckpoint")
+        """Get the timestamp of the last checkpoint.
+
+        Cached until the estimated end of the current epoch (ts_checkpoint + liveness_period).
+        """
+        now = time.time()
+        cache_key = "ts_checkpoint"
+
+        # Check if we have a valid cached value
+        if cache_key in self._contract_params_cache:
+            ts = self._contract_params_cache[cache_key]
+            # Use liveness period to determine if we should re-check
+            if now < ts + self.liveness_period:
+                return ts
+
+            # If past expected epoch end, check at most once per minute
+            last_checked = self._contract_params_cache.get(f"{cache_key}_last_checked", 0)
+            if now - last_checked < 60:
+                return ts
+
+        # Fetch new value
+        ts = self.call("tsCheckpoint")
+        self._contract_params_cache[cache_key] = ts
+        self._contract_params_cache[f"{cache_key}_last_checked"] = now
+        return ts
+
+    def clear_epoch_cache(self) -> None:
+        """Clear cache for epoch-dependent properties."""
+        self._contract_params_cache.pop("ts_checkpoint", None)
+        self._contract_params_cache.pop("ts_checkpoint_last_checked", None)
+        logger.debug(f"Cleared epoch cache for StakingContract {self.address}")
 
     def get_required_requests(self, use_liveness_period: bool = True) -> int:
         """Calculate the required requests for the current epoch.
@@ -246,6 +267,81 @@ class StakingContract(ContractInstance):
             (time_diff * self.activity_checker.liveness_ratio) / 1e18 + requests_safety_margin
         )
 
+    @property
+    def activity_checker_address_value(self) -> EthereumAddress:
+        """Get the activity checker address."""
+        if self._activity_checker_address is None:
+            self._activity_checker_address = self.call("activityChecker")
+        return self._activity_checker_address
+
+    @property
+    def activity_checker_address(self) -> EthereumAddress:
+        """Backwards compatibility for activity_checker_address."""
+        return self.activity_checker_address_value
+
+    @property
+    def activity_checker(self) -> ActivityCheckerContract:
+        """Get the activity checker contract."""
+        if self._activity_checker is None:
+            self._activity_checker = ActivityCheckerContract(
+                self.activity_checker_address_value, chain_name=self.chain_name
+            )
+        return self._activity_checker
+
+    @property
+    def available_rewards(self) -> int:
+        """Get available rewards."""
+        if "availableRewards" not in self._contract_params_cache:
+            self._contract_params_cache["availableRewards"] = self.call("availableRewards")
+        return self._contract_params_cache["availableRewards"]
+
+    @property
+    def balance(self) -> int:
+        """Get contract balance."""
+        if "balance" not in self._contract_params_cache:
+            self._contract_params_cache["balance"] = self.call("balance")
+        return self._contract_params_cache["balance"]
+
+    @property
+    def liveness_period(self) -> int:
+        """Get liveness period."""
+        if "livenessPeriod" not in self._contract_params_cache:
+            self._contract_params_cache["livenessPeriod"] = self.call("livenessPeriod")
+        return self._contract_params_cache["livenessPeriod"]
+
+    @property
+    def rewards_per_second(self) -> int:
+        """Get rewards per second."""
+        if "rewardsPerSecond" not in self._contract_params_cache:
+            self._contract_params_cache["rewardsPerSecond"] = self.call("rewardsPerSecond")
+        return self._contract_params_cache["rewardsPerSecond"]
+
+    @property
+    def max_num_services(self) -> int:
+        """Get max number of services."""
+        if "maxNumServices" not in self._contract_params_cache:
+            self._contract_params_cache["maxNumServices"] = self.call("maxNumServices")
+        return self._contract_params_cache["maxNumServices"]
+
+    @property
+    def min_staking_deposit(self) -> int:
+        """Get min staking deposit."""
+        if "minStakingDeposit" not in self._contract_params_cache:
+            self._contract_params_cache["minStakingDeposit"] = self.call("minStakingDeposit")
+        return self._contract_params_cache["minStakingDeposit"]
+
+    @property
+    def min_staking_duration_hours(self) -> float:
+        """Get min staking duration in hours."""
+        return self.min_staking_duration / 3600
+
+    @property
+    def staking_token_address(self) -> EthereumAddress:
+        """Get staking token address."""
+        if "stakingToken" not in self._contract_params_cache:
+            self._contract_params_cache["stakingToken"] = self.call("stakingToken")
+        return self._contract_params_cache["stakingToken"]
+
     def is_liveness_ratio_passed(
         self,
         current_nonces: tuple,