iwa 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

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/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/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/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/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/plugins/olas/constants.py

@@ -54,10 +54,10 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
         # Legacy mech - used by NON-MM TRADER staking contracts (e.g., "Expert X (Yk OLAS)")
         # Activity checker calls agentMech.getRequestsCount(multisig) to count requests.
         "OLAS_MECH": EthereumAddress("0x77af31De935740567Cf4fF1986D04B2c964A786a"),
-        # NEW Marketplace (v2) - used by MM staking contracts (e.g., "Expert X MM (Yk OLAS)")
-        # Services staked in "Expert X MM" contracts MUST use marketplace requests.
+        # Marketplace v2 - used by newer MM staking contracts (e.g., "Expert X MM v2 (Yk OLAS)")
+        # Services staked in MM v2 contracts MUST use marketplace requests.
         # Legacy mech requests will NOT be counted by the activity checker.
-        "OLAS_MECH_MARKETPLACE": EthereumAddress("0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB"),
+        "OLAS_MECH_MARKETPLACE_V2": EthereumAddress("0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB"),
         # Default priority mech for marketplace requests (from olas-operate-middleware)
         # This is the mech that will process requests sent via the marketplace.
         # Source: https://github.com/valory-xyz/olas-operate-middleware/blob/main/operate/ledger/profiles.py
@@ -65,8 +65,9 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
         "OLAS_MECH_MARKETPLACE_PRIORITY": EthereumAddress(
             "0xC05e7412439bD7e91730a6880E18d5D5873F632C"
         ),
-        # OLD Marketplace (v1) - legacy, kept for reference
-        "OLAS_MECH_MARKETPLACE_OLD": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
+        # Marketplace v1 (VERSION 1.0.0) - older MM contracts (e.g., "Expert 17 MM v1")
+        # Uses different request signature than v2. trader_ant uses this.
+        "OLAS_MECH_MARKETPLACE_V1": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
     },
     "ethereum": {
         "OLAS_SERVICE_REGISTRY": EthereumAddress("0x48b6F34dDAf31f94086BFB45e69e0618DDe3677b"),
@@ -75,49 +76,50 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
     "base": {
         "OLAS_SERVICE_REGISTRY": EthereumAddress("0x3841C312061daB948332A78F042Ec61Ad09fc3D8"),
         "OLAS_SERVICE_MANAGER": EthereumAddress("0xF36183B106692DeD8b6e3B2B7347C9665f8a09B1"),
-        "OLAS_MECH_MARKETPLACE": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
+        "OLAS_MECH_MARKETPLACE_V1": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
     },
 }
 
 # TRADER-compatible staking contracts categorized by chain
 # See https://govern.olas.network/contracts
-# NOTE: All TRADER staking contracts use the LEGACY MECH for activity tracking.
-# The activity checker calls agentMech.getRequestsCount(multisig), where agentMech
-# is hardcoded to the legacy mech (0x77af31De935740567Cf4fF1986D04B2c964A786a).
 #
-# This means:
-#   - Legacy mech requests (use_marketplace=False) -> COUNT for liveness rewards
-#   - Marketplace mech requests (use_marketplace=True) -> DO NOT COUNT
+# Categories (verified on-chain via activity checker's mechMarketplace):
+#   - Legacy: No marketplace, uses legacy mech (0x77af31De...). agentMech.getRequestsCount()
+#   - MM v1: Old marketplace (0x4554fE75...). mechMarketplace.mapRequestCounts()
+#   - MM v2: New marketplace (0x735FAAb1...). mechMarketplace.mapRequestCounts()
 #
-# For staking rewards, services MUST use legacy mech requests.
+# IMPORTANT: Services MUST use the correct mech request type for their staking contract!
 OLAS_TRADER_STAKING_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
     "gnosis": {
-        "Hobbyist 1 (100 OLAS)": EthereumAddress("0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"),
-        "Hobbyist 2 (500 OLAS)": EthereumAddress("0x238EB6993b90A978ec6AAD7530D6429c949C08DA"),
-        "Expert (1k OLAS)": EthereumAddress("0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e"),
-        "Expert 2 (1k OLAS)": EthereumAddress("0xb964e44c126410df341ae04B13aB10A985fE3513"),
-        "Expert 3 (2k OLAS)": EthereumAddress("0x80faD33Cadb5F53f9D29F02Db97D682E8B101618"),
-        "Expert 4 (10k OLAS)": EthereumAddress("0xaD9d891134443B443D7F30013c7e14Fe27F2E029"),
-        "Expert 5 (10k OLAS)": EthereumAddress("0xE56dF1E563De1B10715cB313D514af350D207212"),
-        "Expert 6 (1k OLAS)": EthereumAddress("0x2546214aEE7eEa4bEE7689C81231017CA231Dc93"),
-        "Expert 7 (10k OLAS)": EthereumAddress("0xD7A3C8b975f71030135f1a66E9e23164d54fF455"),
-        "Expert 8 (2k OLAS)": EthereumAddress("0x356C108D49C5eebd21c84c04E9162de41933030c"),
-        "Expert 9 (10k OLAS)": EthereumAddress("0x17dBAe44BC5618Cc254055B386A29576b4F87015"),
-        "Expert 10 (10k OLAS)": EthereumAddress("0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"),
-        "Expert 11 (10k OLAS)": EthereumAddress("0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"),
-        "Expert 12 (10k OLAS)": EthereumAddress("0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"),
-        "Expert 15 (10k OLAS)": EthereumAddress("0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1"),
-        "Expert 16 (10k OLAS)": EthereumAddress("0x6c65430515c70a3f5E62107CC301685B7D46f991"),
-        "Expert 17 (10k OLAS)": EthereumAddress("0x1430107A785C3A36a0C1FC0ee09B9631e2E72aFf"),
-        "Expert 18 (10k OLAS)": EthereumAddress("0x041e679d04Fc0D4f75Eb937Dea729Df09a58e454"),
-        "Expert 3 MM (1k OLAS)": EthereumAddress("0x75eeca6207be98cac3fde8a20ecd7b01e50b3472"),
-        "Expert 4 MM (2k OLAS)": EthereumAddress("0x9c7f6103e3a72e4d1805b9c683ea5b370ec1a99f"),
-        "Expert 5 MM (10k OLAS)": EthereumAddress("0xcdC603e0Ee55Aae92519f9770f214b2Be4967f7d"),
-        "Expert 6 MM (10k OLAS)": EthereumAddress("0x22d6cd3d587d8391c3aae83a783f26c67ab54a85"),
-        "Expert 7 MM (10k OLAS)": EthereumAddress("0xaaecdf4d0cbd6ca0622892ac6044472f3912a5f3"),
-        "Expert 8 MM (10k OLAS)": EthereumAddress("0x168aed532a0cd8868c22fc77937af78b363652b1"),
-        "Expert 9 MM (10k OLAS)": EthereumAddress("0xdda9cd214f12e7c2d58e871404a0a3b1177065c8"),
-        "Expert 10 MM (10k OLAS)": EthereumAddress("0x53a38655b4e659ef4c7f88a26fbf5c67932c7156"),
+        # === LEGACY (no marketplace) ===
+        "Hobbyist 1 Legacy (100 OLAS)": EthereumAddress("0x389B46C259631Acd6a69Bde8B6cEe218230bAE8C"),
+        "Hobbyist 2 Legacy (500 OLAS)": EthereumAddress("0x238EB6993b90A978ec6AAD7530D6429c949C08DA"),
+        "Expert Legacy (1k OLAS)": EthereumAddress("0x5344B7DD311e5d3DdDd46A4f71481Bd7b05AAA3e"),
+        "Expert 2 Legacy (1k OLAS)": EthereumAddress("0xb964e44c126410df341ae04B13aB10A985fE3513"),
+        "Expert 3 Legacy (2k OLAS)": EthereumAddress("0x80faD33Cadb5F53f9D29F02Db97D682E8B101618"),
+        "Expert 4 Legacy (10k OLAS)": EthereumAddress("0xaD9d891134443B443D7F30013c7e14Fe27F2E029"),
+        "Expert 5 Legacy (10k OLAS)": EthereumAddress("0xE56dF1E563De1B10715cB313D514af350D207212"),
+        "Expert 6 Legacy (1k OLAS)": EthereumAddress("0x2546214aEE7eEa4bEE7689C81231017CA231Dc93"),
+        "Expert 7 Legacy (10k OLAS)": EthereumAddress("0xD7A3C8b975f71030135f1a66E9e23164d54fF455"),
+        "Expert 8 Legacy (2k OLAS)": EthereumAddress("0x356C108D49C5eebd21c84c04E9162de41933030c"),
+        "Expert 9 Legacy (10k OLAS)": EthereumAddress("0x17dBAe44BC5618Cc254055B386A29576b4F87015"),
+        "Expert 10 Legacy (10k OLAS)": EthereumAddress("0xB0ef657b8302bd2c74B6E6D9B2b4b39145b19c6f"),
+        "Expert 11 Legacy (10k OLAS)": EthereumAddress("0x3112c1613eAC3dBAE3D4E38CeF023eb9E2C91CF7"),
+        "Expert 12 Legacy (10k OLAS)": EthereumAddress("0xF4a75F476801B3fBB2e7093aCDcc3576593Cc1fc"),
+        # === MM v1 (old marketplace 0x4554fE75...) ===
+        "Expert 15 MM v1 (10k OLAS)": EthereumAddress("0x88eB38FF79fBa8C19943C0e5Acfa67D5876AdCC1"),
+        "Expert 16 MM v1 (10k OLAS)": EthereumAddress("0x6c65430515c70a3f5E62107CC301685B7D46f991"),
+        "Expert 17 MM v1 (10k OLAS)": EthereumAddress("0x1430107A785C3A36a0C1FC0ee09B9631e2E72aFf"),
+        "Expert 18 MM v1 (10k OLAS)": EthereumAddress("0x041e679d04Fc0D4f75Eb937Dea729Df09a58e454"),
+        # === MM v2 (new marketplace 0x735FAAb1...) ===
+        "Expert 3 MM v2 (1k OLAS)": EthereumAddress("0x75eeca6207be98cac3fde8a20ecd7b01e50b3472"),
+        "Expert 4 MM v2 (2k OLAS)": EthereumAddress("0x9c7f6103e3a72e4d1805b9c683ea5b370ec1a99f"),
+        "Expert 5 MM v2 (10k OLAS)": EthereumAddress("0xcdC603e0Ee55Aae92519f9770f214b2Be4967f7d"),
+        "Expert 6 MM v2 (10k OLAS)": EthereumAddress("0x22d6cd3d587d8391c3aae83a783f26c67ab54a85"),
+        "Expert 7 MM v2 (10k OLAS)": EthereumAddress("0xaaecdf4d0cbd6ca0622892ac6044472f3912a5f3"),
+        "Expert 8 MM v2 (10k OLAS)": EthereumAddress("0x168aed532a0cd8868c22fc77937af78b363652b1"),
+        "Expert 9 MM v2 (10k OLAS)": EthereumAddress("0xdda9cd214f12e7c2d58e871404a0a3b1177065c8"),
+        "Expert 10 MM v2 (10k OLAS)": EthereumAddress("0x53a38655b4e659ef4c7f88a26fbf5c67932c7156"),
     },
     "ethereum": {},
     "base": {},