iwa 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

iwa/plugins/olas/service_manager/base.py

@@ -11,6 +11,7 @@ from iwa.core.wallet import Wallet
 from iwa.plugins.olas.constants import OLAS_CONTRACTS
 from iwa.plugins.olas.contracts.service import ServiceManagerContract, ServiceRegistryContract
 from iwa.plugins.olas.models import OlasConfig
+from iwa.web.cache import CacheTTL, response_cache
 
 
 class ServiceManagerBase:
@@ -99,11 +100,14 @@ class ServiceManagerBase:
             return None
         return self.registry.get_service(self.service.service_id)
 
-    def get_service_state(self, service_id: Optional[int] = None) -> str:
+    def get_service_state(
+        self, service_id: Optional[int] = None, force_refresh: bool = False
+    ) -> str:
         """Get the state of a service as a string.
 
         Args:
             service_id: Optional service ID. If not provided, uses the active service.
+            force_refresh: If True, bypass cache and fetch fresh data.
 
         Returns:
             The state name (e.g., 'DEPLOYED') or 'UNKNOWN' if not found.
@@ -114,9 +118,24 @@ class ServiceManagerBase:
                 return "UNKNOWN"
             service_id = self.service.service_id
 
-        try:
-            info = self.registry.get_service(service_id)
-            return info["state"].name
-        except Exception as e:
-            logger.debug(f"Failed to get service state for {service_id}: {e}")
-            return "UNKNOWN"
+        # Build cache key using service_key if available, else chain:id
+        if self.service and self.service.key:
+            cache_key = f"service_state:{self.service.key}"
+        else:
+            cache_key = f"service_state:{self.chain_name}:{service_id}"
+
+        # Invalidate cache if force refresh requested
+        if force_refresh:
+            response_cache.invalidate(cache_key)
+
+        def fetch_state():
+            try:
+                info = self.registry.get_service(service_id)
+                return info["state"].name
+            except Exception as e:
+                logger.debug(f"Failed to get service state for {service_id}: {e}")
+                return "UNKNOWN"
+
+        return response_cache.get_or_compute(
+            cache_key, fetch_state, CacheTTL.SERVICE_STATE
+        )

iwa/plugins/olas/service_manager/drain.py

@@ -7,6 +7,7 @@ from loguru import logger
 from iwa.core.contracts.erc20 import ERC20Contract
 from iwa.plugins.olas.constants import OLAS_TOKEN_ADDRESS_GNOSIS
 from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
+from iwa.web.cache import response_cache
 
 
 class DrainManagerMixin:
@@ -110,6 +111,11 @@ class DrainManagerMixin:
             logger.warning("RewardClaimed event not found, using estimated amount")
 
         logger.info(f"Successfully claimed {claimed_amount / 1e18:.4f} OLAS rewards")
+
+        # Invalidate caches - rewards and balances changed
+        response_cache.invalidate(f"staking_status:{self.service.key}")
+        response_cache.invalidate(f"balances:{self.service.key}")
+
         return True, claimed_amount
 
     def withdraw_rewards(self) -> Tuple[bool, float]:
@@ -179,6 +185,9 @@ class DrainManagerMixin:
             logger.error("Failed to transfer OLAS")
             return False, 0
 
+        # Invalidate balances cache - OLAS moved from Safe
+        response_cache.invalidate(f"balances:{self.service.key}")
+
         logger.info(f"Withdrew {olas_amount:.4f} OLAS to {withdrawal_tag}")
         return True, olas_amount
 
@@ -238,6 +247,9 @@ class DrainManagerMixin:
             logger.info("Drain returned empty but rewards were claimed. Reporting partial success.")
             drained["safe_rewards_only"] = {"olas": claimed_rewards / 1e18}
 
+        # Invalidate balances cache - multiple accounts drained
+        response_cache.invalidate(f"balances:{self.service.key}")
+
         logger.info(f"Drain complete. Accounts drained: {list(drained.keys())}")
         return drained
 

iwa/plugins/olas/service_manager/lifecycle.py

@@ -75,6 +75,7 @@ from iwa.plugins.olas.constants import (
 )
 from iwa.plugins.olas.contracts.service import ServiceState
 from iwa.plugins.olas.models import Service
+from iwa.web.cache import response_cache
 
 
 class LifecycleManagerMixin:
@@ -899,6 +900,10 @@ class LifecycleManagerMixin:
             except Exception as e:
                 logger.error(f"[DEPLOY] Failed to fund multisig: {e}")
 
+        # Invalidate service state cache
+        if self.service:
+            response_cache.invalidate(f"service_state:{self.service.key}")
+
         logger.info("[DEPLOY] Success - service is now DEPLOYED")
         return multisig_address
 
@@ -949,6 +954,9 @@ class LifecycleManagerMixin:
             logger.error("Terminate service event not found")
             return False
 
+        # Invalidate service state cache
+        response_cache.invalidate(f"service_state:{self.service.key}")
+
         logger.info("Service terminated successfully")
         return True
 
@@ -984,6 +992,9 @@ class LifecycleManagerMixin:
             logger.error("Unbond service event not found")
             return False
 
+        # Invalidate service state cache
+        response_cache.invalidate(f"service_state:{self.service.key}")
+
         logger.info("Service unbonded successfully")
         return True
 

iwa/plugins/olas/service_manager/staking.py

@@ -55,6 +55,7 @@ from iwa.core.types import EthereumAddress
 from iwa.core.utils import get_tx_hash
 from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
 from iwa.plugins.olas.models import StakingStatus
+from iwa.web.cache import CacheTTL, response_cache
 
 
 class StakingManagerMixin:
@@ -100,9 +101,12 @@ class StakingManagerMixin:
 
         return address
 
-    def get_staking_status(self) -> Optional[StakingStatus]:
+    def get_staking_status(self, force_refresh: bool = False) -> Optional[StakingStatus]:
         """Get comprehensive staking status for the active service.
 
+        Args:
+            force_refresh: If True, bypass cache and fetch fresh data.
+
         Returns:
             StakingStatus with liveness check info, or None if no service loaded.
 
@@ -111,6 +115,22 @@ class StakingManagerMixin:
             logger.error("No active service")
             return None
 
+        # Build cache key
+        cache_key = f"staking_status:{self.service.key}"
+
+        # Invalidate cache if force refresh requested
+        if force_refresh:
+            response_cache.invalidate(cache_key)
+
+        def fetch_staking_status():
+            return self._fetch_staking_status_impl()
+
+        return response_cache.get_or_compute(
+            cache_key, fetch_staking_status, CacheTTL.STAKING_STATUS
+        )
+
+    def _fetch_staking_status_impl(self) -> Optional[StakingStatus]:
+        """Internal implementation for fetching staking status (uncached)."""
         service_id = self.service.service_id
         staking_address = self.service.staking_contract_address
 
@@ -534,6 +554,11 @@ class StakingManagerMixin:
         self.service.staking_contract_address = EthereumAddress(staking_contract.address)
         self._update_and_save_service_state()
 
+        # Invalidate caches - state and balances changed
+        response_cache.invalidate(f"service_state:{self.service.key}")
+        response_cache.invalidate(f"staking_status:{self.service.key}")
+        response_cache.invalidate(f"balances:{self.service.key}")
+
         logger.info(f"[STAKE] Service {self.service.service_id} is now STAKED")
         return True
 
@@ -620,10 +645,15 @@ class StakingManagerMixin:
         self.service.staking_contract_address = None
         self._update_and_save_service_state()
 
+        # Invalidate caches - state and balances changed
+        response_cache.invalidate(f"service_state:{self.service.key}")
+        response_cache.invalidate(f"staking_status:{self.service.key}")
+        response_cache.invalidate(f"balances:{self.service.key}")
+
         logger.info("Service unstaked successfully")
         return True
 
-    def call_checkpoint(
+    def call_checkpoint(  # noqa: C901
         self,
         staking_contract: Optional[StakingContract] = None,
         grace_period_seconds: int = 600,
@@ -720,4 +750,8 @@ class StakingManagerMixin:
             service_ids = [e["args"]["serviceId"] for e in inactivity_warnings]
             logger.warning(f"Services with inactivity warnings: {service_ids}")
 
+        # Invalidate staking status cache - epoch info changed
+        if self.service:
+            response_cache.invalidate(f"staking_status:{self.service.key}")
+
         return True

iwa/plugins/olas/tests/test_service_manager_errors.py

@@ -170,14 +170,14 @@ def test_service_manager_staking_status_failures(mock_manager):
     manager.service = Service(service_name="t", chain_name="gnosis", service_id=1, agent_ids=[1])
     # Staking contract missing
     manager.service.staking_contract_address = None
-    status = manager.get_staking_status()
+    status = manager.get_staking_status(force_refresh=True)
     assert status.is_staked is False
 
     # Exception in contract loading
     manager.service.staking_contract_address = VALID_ADDR
     with patch("iwa.plugins.olas.service_manager.staking.StakingContract") as mock_staking_cls:
         mock_staking_cls.side_effect = Exception("fail")
-        status = manager.get_staking_status()
+        status = manager.get_staking_status(force_refresh=True)
         assert status.staking_state == "ERROR"
 
         # Exception in get_service_info
@@ -185,7 +185,7 @@ def test_service_manager_staking_status_failures(mock_manager):
         mock_staking = mock_staking_cls.return_value
         mock_staking.get_staking_state.return_value = StakingState.STAKED
         mock_staking.get_service_info.side_effect = Exception("fail")
-        status = manager.get_staking_status()
+        status = manager.get_staking_status(force_refresh=True)
         assert status.is_staked is True
         assert status.mech_requests_this_epoch == 0
 

iwa/plugins/olas/tests/test_service_staking.py

@@ -194,7 +194,7 @@ def test_sm_get_staking_status_with_full_info(mock_wallet):
             patch("iwa.plugins.olas.service_manager.staking.Web3") as mock_web3,
         ):
             mock_web3.from_wei.return_value = 0.001
-            status = sm.get_staking_status()
+            status = sm.get_staking_status(force_refresh=True)
             assert status.is_staked is True
             assert status.epoch_number == 5
 

iwa/web/cache.py

@@ -0,0 +1,143 @@
+"""Response cache for web API endpoints to reduce RPC calls."""
+
+import os
+import time
+from threading import Lock
+from typing import Any, Callable, Dict, Optional, TypeVar
+
+from loguru import logger
+
+T = TypeVar("T")
+
+
+class ResponseCache:
+    """Singleton TTL cache for API response data.
+
+    Caches expensive query results (service status, balances, etc.)
+    to prevent redundant RPC calls when refreshing the web UI.
+    """
+
+    _instance: Optional["ResponseCache"] = None
+    _lock = Lock()
+
+    def __new__(cls) -> "ResponseCache":
+        """Ensure singleton instance."""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._cache: Dict[str, Any] = {}
+                cls._instance._timestamps: Dict[str, float] = {}
+                cls._instance._enabled = os.environ.get("IWA_RESPONSE_CACHE", "1") != "0"
+        return cls._instance
+
+    def get(self, key: str, ttl_seconds: int = 60) -> Optional[Any]:
+        """Get a cached value if it exists and hasn't expired.
+
+        Args:
+            key: Cache key.
+            ttl_seconds: Time-to-live in seconds.
+
+        Returns:
+            Cached value or None if not found/expired.
+
+        """
+        if not self._enabled:
+            return None
+
+        with self._lock:
+            if key in self._cache:
+                created_at = self._timestamps.get(key, 0)
+                if time.time() - created_at < ttl_seconds:
+                    logger.debug(f"Cache HIT: {key}")
+                    return self._cache[key]
+                else:
+                    # Expired
+                    del self._cache[key]
+                    del self._timestamps[key]
+        return None
+
+    def set(self, key: str, value: Any) -> None:
+        """Store a value in the cache.
+
+        Args:
+            key: Cache key.
+            value: Value to cache.
+
+        """
+        if not self._enabled:
+            return
+
+        with self._lock:
+            self._cache[key] = value
+            self._timestamps[key] = time.time()
+            logger.debug(f"Cache SET: {key}")
+
+    def invalidate(self, pattern: Optional[str] = None) -> None:
+        """Invalidate cache entries.
+
+        Args:
+            pattern: If provided, invalidate keys containing this pattern.
+                    If None, clear entire cache.
+
+        """
+        with self._lock:
+            if pattern is None:
+                self._cache.clear()
+                self._timestamps.clear()
+                logger.debug("Cache cleared")
+            else:
+                keys_to_remove = [k for k in self._cache if pattern in k]
+                for key in keys_to_remove:
+                    del self._cache[key]
+                    del self._timestamps[key]
+                if keys_to_remove:
+                    logger.debug(f"Cache invalidated {len(keys_to_remove)} entries matching '{pattern}'")
+
+    def get_or_compute(
+        self,
+        key: str,
+        compute_fn: Callable[[], T],
+        ttl_seconds: int = 60,
+    ) -> T:
+        """Get cached value or compute and cache it.
+
+        Args:
+            key: Cache key.
+            compute_fn: Function to compute the value if not cached.
+            ttl_seconds: Time-to-live in seconds.
+
+        Returns:
+            Cached or computed value.
+
+        """
+        cached = self.get(key, ttl_seconds)
+        if cached is not None:
+            return cached
+
+        value = compute_fn()
+        self.set(key, value)
+        return value
+
+
+# Singleton accessor
+response_cache = ResponseCache()
+
+
+# TTL constants for different data types (in seconds)
+class CacheTTL:
+    """Standard TTL values for different data types."""
+
+    # Service state changes infrequently (after user actions)
+    SERVICE_STATE = 120  # 2 minutes
+
+    # Staking status (epoch info, rewards) changes slowly
+    STAKING_STATUS = 60  # 1 minute
+
+    # Balances can change via external transactions
+    BALANCES = 30  # 30 seconds
+
+    # Account list rarely changes
+    ACCOUNTS = 300  # 5 minutes
+
+    # Basic service info (config-based) rarely changes
+    SERVICE_BASIC = 120  # 2 minutes

iwa/web/routers/accounts.py

@@ -7,6 +7,7 @@ from loguru import logger
 from slowapi import Limiter
 from slowapi.util import get_remote_address
 
+from iwa.web.cache import CacheTTL, response_cache
 from iwa.web.dependencies import verify_auth, wallet
 from iwa.web.models import AccountCreateRequest, SafeCreateRequest
 
@@ -24,39 +25,62 @@ limiter = Limiter(key_func=get_remote_address)
 def get_accounts(
     chain: str = "gnosis",
     tokens: str = None,
+    refresh: bool = False,
     auth: bool = Depends(verify_auth),
 ):
-    """Get all accounts and their balances for a specific chain."""
+    """Get all accounts and their balances for a specific chain.
+
+    Args:
+        chain: Chain name to query balances on.
+        tokens: Comma-separated list of token names to fetch balances for.
+        refresh: If true, bypass cache and fetch fresh data.
+        auth: Authentication dependency (injected).
+
+    """
     if not chain.replace("-", "").isalnum():
         raise HTTPException(status_code=400, detail="Invalid chain name")
-    try:
-        # Parse tokens from query parameter or use defaults
-        if tokens:
-            token_names = [t.strip() for t in tokens.split(",") if t.strip()]
-        else:
-            token_names = ["native", "OLAS", "WXDAI", "USDC"]
-
-        accounts_data, balances = wallet.get_accounts_balances(chain, token_names)
-
-        # Merge data
-        result = []
-        for addr, data in accounts_data.items():
-            account_balances = balances.get(addr, {})
-            # Determine account type: if it has 'signers' attribute, it's a Safe
-            account_type = "Safe" if hasattr(data, "signers") else "EOA"
-            result.append(
-                {
-                    "address": addr,
-                    "tag": data.tag,
-                    "type": account_type,
-                    "balances": account_balances,
-                }
+
+    # Parse tokens from query parameter or use defaults
+    if tokens:
+        token_names = [t.strip() for t in tokens.split(",") if t.strip()]
+    else:
+        token_names = ["native", "OLAS", "WXDAI", "USDC"]
+
+    # Create cache key from chain and tokens
+    cache_key = f"accounts:{chain}:{','.join(sorted(token_names))}"
+
+    # Invalidate cache if refresh requested
+    if refresh:
+        response_cache.invalidate(cache_key)
+
+    def fetch_accounts():
+        try:
+            accounts_data, balances = wallet.get_accounts_balances(
+                chain, token_names
             )
 
-        return result
-    except Exception as e:
-        logger.error(f"Error fetching accounts: {e}")
-        raise HTTPException(status_code=500, detail=str(e)) from None
+            # Merge data
+            result = []
+            for addr, data in accounts_data.items():
+                account_balances = balances.get(addr, {})
+                # Determine account type: if it has 'signers' attribute, it's a Safe
+                account_type = "Safe" if hasattr(data, "signers") else "EOA"
+                result.append(
+                    {
+                        "address": addr,
+                        "tag": data.tag,
+                        "type": account_type,
+                        "balances": account_balances,
+                    }
+                )
+            return result
+        except Exception as e:
+            logger.error(f"Error fetching accounts: {e}")
+            raise HTTPException(status_code=500, detail=str(e)) from None
+
+    return response_cache.get_or_compute(
+        cache_key, fetch_accounts, CacheTTL.BALANCES
+    )
 
 
 @router.post(
@@ -69,6 +93,8 @@ def create_eoa(request: Request, req: AccountCreateRequest, auth: bool = Depends
     """Create a new EOA account with the given tag."""
     try:
         wallet.key_storage.generate_new_account(req.tag)
+        # Invalidate accounts cache (new account added)
+        response_cache.invalidate("accounts:")
         return {"status": "success"}
     except Exception as e:
         raise HTTPException(status_code=400, detail=str(e)) from None
@@ -108,6 +134,8 @@ def create_safe(request: Request, req: SafeCreateRequest, auth: bool = Depends(v
                 req.tag,
                 salt_nonce,
             )
+        # Invalidate accounts cache (new Safe added)
+        response_cache.invalidate("accounts:")
         return {"status": "success"}
     except Exception as e:
         logger.error(f"Error creating Safe: {e}")