iwa 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

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,

iwa/plugins/olas/events.py

@@ -0,0 +1,141 @@
+"""Event-based cache invalidation for Olas contracts."""
+
+
+from loguru import logger
+
+from iwa.core.contracts.cache import ContractCache
+from iwa.plugins.olas.contracts.staking import StakingContract
+
+
+class OlasEventInvalidator:
+    """Monitors OLAS events and invalidates caches."""
+
+    def __init__(self, chain_name: str = "gnosis"):
+        """Initialize the invalidator."""
+        self.chain_name = chain_name
+        self.contract_cache = ContractCache()
+
+        # We need to find active staking contracts to monitor
+        # For now, we'll use a dynamic approach or configuration
+        # Ideally, this service would know about all deployed staking contracts
+        # But efficiently, we might just want to monitor the ones in our cache?
+        # A simple approach for this MVP: Monitor contracts currently in the cache
+        # OR monitor a known set of staking contracts from constants.
+
+        # Since EventMonitor requires a list of addresses upfront, let's use the ones
+        # defined in constants if available, or just rely on what's active.
+        # However, EventMonitor checks transfers, not generic logs for specific events.
+        # The base EventMonitor in iwa.core.monitor is too specific (transfers).
+        # We should implement a specific loop here or extend EventMonitor.
+        # To avoid complex inheritance of a class not designed for extension (EventMonitor),
+        # we will implement a focused loop using the same pattern.
+
+        from iwa.core.chain import ChainInterfaces
+        from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
+
+        self.chain_interface = ChainInterfaces().get(chain_name)
+        self.web3 = self.chain_interface.web3
+
+        # Get addresses to monitor
+        contracts = OLAS_TRADER_STAKING_CONTRACTS.get(chain_name, {})
+        self.staking_addresses = [addr for _, addr in contracts.items()]
+
+        self.running = False
+
+    def start(self):
+        """Start the event monitoring loop."""
+        import threading
+
+        self.running = True
+        thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        thread.start()
+        logger.info(f"Started OlasEventInvalidator for {len(self.staking_addresses)} contracts")
+
+    def stop(self):
+        """Stop the monitoring loop."""
+        self.running = False
+
+    def _monitor_loop(self):
+        """Main monitoring loop."""
+        import time
+
+        try:
+            last_block = self.web3.eth.block_number
+        except Exception:
+            last_block = 0
+
+        while self.running:
+            try:
+                current_block = self.web3.eth.block_number
+
+                if current_block > last_block:
+                    self._check_events(last_block + 1, current_block)
+                    last_block = current_block
+
+            except Exception as e:
+                logger.error(f"Error in OlasEventInvalidator: {e}")
+
+            time.sleep(10) # check every 10 seconds
+
+    def _check_events(self, from_block: int, to_block: int):
+        """Check for relevant events in the block range."""
+        # Cap range
+        if to_block - from_block > 100:
+            from_block = to_block - 100
+
+        # We care about Checkpoint events on StakingContracts
+        # Event signature for Checkpoint: Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)
+        # Actually easier to use the contract instance to get the topic or event object
+
+        # Need ABI for this. Let's assume we can get it from a dummy contract instance
+        if not self.staking_addresses:
+            return
+
+        # 1. Checkpoint events
+        # Topic 0 for Checkpoint event
+        # We can construct a filter for all staking addresses
+
+        try:
+            # Ensure contract is cached for later use
+            self.contract_cache.get_contract(
+                StakingContract, self.staking_addresses[0], self.chain_name
+            )
+
+
+            logs = self.web3.eth.get_logs({
+                "fromBlock": from_block,
+                "toBlock": to_block,
+                "address": self.staking_addresses,
+                "topics": [self.web3.keccak(text="Checkpoint(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)").hex()]
+                # Note: signature might vary, safer to use the event object if ABI allows
+            })
+
+            # If we used the contract event object to filter, it handles the topic generation:
+            # logs = checkpoint_event_abi.get_logs(fromBlock=from_block, toBlock=to_block)
+            # But get_logs on the contract object filters by THAT contract address usually?
+            # web3.eth.get_logs is broader.
+
+            for log in logs:
+                addr = log["address"]
+                logger.info(f"Checkpoint detected on {addr} at block {log['blockNumber']}")
+
+                # Invalidate cache for this contract
+                # We want to call clear_epoch_cache on the EXISTING cached instance if present
+                # ContractCache().get_contract(...) might return it or create new.
+                # We need a way to 'get if exists' or assume get_contract is cheap enough.
+                # Specifically we want to clear the EPOCH cache, not just destroy the instance
+                # (though destroying it works too, it's just less efficient for the next call).
+
+                # Option A: Just invalidate the instance
+                # self.contract_cache.invalidate(StakingContract, addr, self.chain_name)
+
+                # Option B: Get instance and clear specific cache (safe public access)
+                instance = self.contract_cache.get_if_cached(
+                    StakingContract, addr, self.chain_name
+                )
+                if instance:
+                    instance.clear_epoch_cache()
+                    logger.debug(f"Cleared epoch cache for {addr}")
+
+        except Exception as e:
+            logger.warning(f"Failed to check logs in invalidator: {e}")

iwa/plugins/olas/plugin.py

@@ -73,12 +73,12 @@ class OlasPlugin(Plugin):
 
             try:
                 chain_interface = ChainInterfaces().get(chain_name)
-                if not chain_interface.chain.rpcs:
+                if not chain_interface.current_rpc:
                     return None, None
             except ValueError:
                 return None, None  # Chain not supported/configured
 
-            ethereum_client = EthereumClient(chain_interface.chain.rpc)
+            ethereum_client = EthereumClient(chain_interface.current_rpc)
             safe = Safe(safe_address, ethereum_client)
             owners = safe.retrieve_owners()
             return owners, True

iwa/plugins/olas/service_manager/base.py

@@ -5,6 +5,7 @@ from typing import Dict, Optional
 from loguru import logger
 
 from iwa.core.chain import ChainInterfaces
+from iwa.core.contracts.cache import ContractCache
 from iwa.core.models import Config
 from iwa.core.wallet import Wallet
 from iwa.plugins.olas.constants import OLAS_CONTRACTS
@@ -65,8 +66,12 @@ class ServiceManagerBase:
         if not registry_address or not manager_address:
             raise ValueError(f"OLAS contracts not found for chain: {chain_name}")
 
-        self.registry = ServiceRegistryContract(registry_address, chain_name=chain_name)
-        self.manager = ServiceManagerContract(manager_address, chain_name=chain_name)
+        self.registry = ContractCache().get_contract(
+            ServiceRegistryContract, registry_address, chain_name=chain_name
+        )
+        self.manager = ContractCache().get_contract(
+            ServiceManagerContract, manager_address, chain_name=chain_name
+        )
         logger.debug(f"[SM-INIT] ServiceManager initialized. Chain: {chain_name}")
         logger.debug(f"[SM-INIT] Registry Address: {self.registry.address}")
         logger.debug(f"[SM-INIT] Manager Address: {self.manager.address}")

iwa/plugins/olas/service_manager/lifecycle.py

@@ -65,6 +65,7 @@ from web3.types import Wei
 
 from iwa.core.chain import ChainInterfaces
 from iwa.core.constants import NATIVE_CURRENCY_ADDRESS, ZERO_ADDRESS
+from iwa.core.contracts.cache import ContractCache
 from iwa.core.types import EthereumAddress
 from iwa.core.utils import get_tx_hash
 from iwa.plugins.olas.constants import (
@@ -485,7 +486,8 @@ class LifecycleManagerMixin:
             agent_id = agent_ids[0]
 
             # Use the ServiceRegistryTokenUtilityContract with official ABI
-            token_utility = ServiceRegistryTokenUtilityContract(
+            token_utility = ContractCache().get_contract(
+                ServiceRegistryTokenUtilityContract,
                 address=str(utility_address),
                 chain_name=self.chain_name,
             )
@@ -759,7 +761,7 @@ class LifecycleManagerMixin:
         logger.info("[REGISTER] Success - service is now FINISHED_REGISTRATION")
         return True
 
-    def deploy(self) -> Optional[str]:  # noqa: C901
+    def deploy(self, fund_multisig: bool = False) -> Optional[str]:  # noqa: C901
         """Deploy the service."""
         logger.info(f"[DEPLOY] Starting deployment for service {self.service.service_id}")
 
@@ -841,6 +843,25 @@ class LifecycleManagerMixin:
         except Exception as e:
             logger.warning(f"[DEPLOY] Failed to register multisig in wallet: {e}")
 
+        # Fund the multisig with 1 xDAI from master if requested (for staking)
+        if fund_multisig:
+            try:
+                funding_amount = Web3.to_wei(1, "ether")
+                logger.info(f"[DEPLOY] Funding multisig {multisig_address} with 1 xDAI from master")
+                tx_hash = self.wallet.send(
+                    from_address_or_tag=self.wallet.master_account.address,
+                    to_address_or_tag=multisig_address,
+                    token_address_or_name="native",
+                    amount_wei=funding_amount,
+                    chain_name=self.chain_name,
+                )
+                if tx_hash:
+                    logger.info(f"[DEPLOY] Funded multisig: {tx_hash}")
+                else:
+                    logger.error("[DEPLOY] Failed to fund multisig")
+            except Exception as e:
+                logger.error(f"[DEPLOY] Failed to fund multisig: {e}")
+
         logger.info("[DEPLOY] Success - service is now DEPLOYED")
         return multisig_address
 
@@ -976,7 +997,10 @@ class LifecycleManagerMixin:
             previous_state = current_state
             logger.info(f"[SPIN-UP] Step {step}: Processing {current_state.name}...")
 
-            if not self._process_spin_up_state(current_state, agent_address, bond_amount_wei):
+            should_fund = staking_contract is not None
+            if not self._process_spin_up_state(
+                current_state, agent_address, bond_amount_wei, fund_multisig=should_fund
+            ):
                 logger.error(f"[SPIN-UP] Step {step} FAILED at state {current_state.name}")
                 return False
 
@@ -1012,6 +1036,7 @@ class LifecycleManagerMixin:
         current_state: ServiceState,
         agent_address: Optional[str],
         bond_amount_wei: Optional[Wei],
+        fund_multisig: bool = False,
     ) -> bool:
         """Process a single state transition for spin up."""
         if current_state == ServiceState.PRE_REGISTRATION:
@@ -1025,8 +1050,8 @@ class LifecycleManagerMixin:
             ):
                 return False
         elif current_state == ServiceState.FINISHED_REGISTRATION:
-            logger.info("[SPIN-UP] Action: deploy()")
-            if not self.deploy():
+            logger.info(f"[SPIN-UP] Action: deploy(fund_multisig={fund_multisig})")
+            if not self.deploy(fund_multisig=fund_multisig):
                 return False
         else:
             logger.error(f"[SPIN-UP] Invalid state: {current_state.name}")

iwa/plugins/olas/service_manager/mech.py

@@ -612,6 +612,15 @@ class MechManagerMixin:
 
             if event_found:
                 logger.info(f"Event '{expected_event}' verified successfully")
+
+                # Log transfer events from receipt
+                from iwa.core.services.transaction import TransferLogger
+
+                transfer_logger = TransferLogger(
+                    self.wallet.account_service, self.registry.chain_interface
+                )
+                transfer_logger.log_transfers(receipt)
+
                 return tx_hash
             else:
                 logger.error(f"Event '{expected_event}' NOT found in transaction logs")

iwa/plugins/olas/service_manager/staking.py

@@ -50,6 +50,7 @@ from typing import Optional
 from loguru import logger
 from web3 import Web3
 
+from iwa.core.contracts.cache import ContractCache
 from iwa.core.types import EthereumAddress
 from iwa.core.utils import get_tx_hash
 from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
@@ -96,7 +97,9 @@ class StakingManagerMixin:
 
         # Load the staking contract
         try:
-            staking = StakingContract(str(staking_address), chain_name=self.chain_name)
+            staking = ContractCache().get_contract(
+                StakingContract, str(staking_address), chain_name=self.chain_name
+            )
         except Exception as e:
             logger.error(f"Failed to load staking contract: {e}")
             return StakingStatus(
@@ -613,7 +616,8 @@ class StakingManagerMixin:
         # Load staking contract if not provided
         if not staking_contract:
             try:
-                staking_contract = StakingContract(
+                staking_contract = ContractCache().get_contract(
+                    StakingContract,
                     str(self.service.staking_contract_address),
                     chain_name=self.service.chain_name,
                 )

iwa/plugins/olas/tests/test_olas_integration.py

@@ -309,7 +309,10 @@ def test_importer_import_service_config_duplicate(mock_wallet):
 
 def test_sm_create_token_utility_missing(mock_wallet):
     """Cover create() with missing token utility (lines 204-206)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
 
         with patch.dict("iwa.plugins.olas.service_manager.base.OLAS_CONTRACTS", {"unknown": {}}):
@@ -320,7 +323,10 @@ def test_sm_create_token_utility_missing(mock_wallet):
 
 def test_sm_get_staking_status_staked_info_fail(mock_wallet):
     """Cover get_staking_status with STAKED but get_service_info fails (lines 843-854)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(
             service_name="t", chain_name="gnosis", service_id=1, staking_contract_address=VALID_ADDR
@@ -341,7 +347,10 @@ def test_sm_get_staking_status_staked_info_fail(mock_wallet):
 
 def test_sm_call_checkpoint_prepare_fail(mock_wallet):
     """Cover call_checkpoint prepare failure (lines 1100-1102)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(
             service_name="t", chain_name="gnosis", service_id=1, staking_contract_address=VALID_ADDR
@@ -360,7 +369,10 @@ def test_sm_call_checkpoint_prepare_fail(mock_wallet):
 
 def test_sm_spin_up_no_service(mock_wallet):
     """Cover spin_up with no service (lines 1167-1170)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
 
@@ -370,7 +382,10 @@ def test_sm_spin_up_no_service(mock_wallet):
 
 def test_sm_spin_up_activation_fail(mock_wallet):
     """Cover spin_up activation failure (lines 1181-1183)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
 
@@ -387,7 +402,10 @@ def test_sm_spin_up_activation_fail(mock_wallet):
 
 def test_sm_wind_down_no_service(mock_wallet):
     """Cover wind_down with no service (lines 1264-1266)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
 
@@ -397,7 +415,10 @@ def test_sm_wind_down_no_service(mock_wallet):
 
 def test_sm_wind_down_nonexistent(mock_wallet):
     """Cover wind_down with non-existent service (lines 1274-1276)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="gnosis", service_id=1)
 
@@ -411,7 +432,10 @@ def test_sm_wind_down_nonexistent(mock_wallet):
 
 def test_sm_mech_request_no_service(mock_wallet):
     """Cover _send_legacy_mech_request with no service (lines 1502-1504)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = None
 
@@ -421,7 +445,10 @@ def test_sm_mech_request_no_service(mock_wallet):
 
 def test_sm_mech_request_no_address(mock_wallet):
     """Cover _send_legacy_mech_request missing mech address (lines 1510-1512)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache, \
+         patch("iwa.plugins.olas.service_manager.staking.ContractCache", mock_cache):
+        mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
         sm = ServiceManager(mock_wallet)
         sm.service = Service(service_name="t", chain_name="unknown", service_id=1)
 
@@ -431,7 +458,8 @@ def test_sm_mech_request_no_address(mock_wallet):
 
 def test_sm_marketplace_mech_no_service(mock_wallet):
     """Cover _send_marketplace_mech_request with no service (lines 1549-1551)."""
-    with patch("iwa.core.models.Config"):
+    with patch("iwa.core.models.Config"), \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache"):
         sm = ServiceManager(mock_wallet)
         sm.service = None
 

iwa/plugins/olas/tests/test_plugin_full.py

@@ -105,7 +105,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 1. No RPC configured
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = []
+        mock_ci.get.return_value.current_rpc = ""
         signers, exists = plugin._get_safe_signers("0x1", "gnosis")
         assert signers is None
         assert exists is None
@@ -113,8 +113,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 2. Safe doesn't exist (raises exception)
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.side_effect = Exception("Generic error")
@@ -126,8 +125,7 @@ def test_get_safe_signers_edge_cases(plugin):
     # 3. Success path
     with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
         mock_ci = mock_ci_cls.return_value
-        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
-        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        mock_ci.get.return_value.current_rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.return_value = ["0xAgent"]

iwa/plugins/olas/tests/test_service_manager.py

@@ -114,11 +114,16 @@ def service_manager(
     mock_service,
 ):
     """ServiceManager fixture with mocked dependencies."""
-    with patch("iwa.plugins.olas.service_manager.base.Config") as local_mock_config:
+    with patch("iwa.plugins.olas.service_manager.base.Config") as local_mock_config, \
+         patch("iwa.plugins.olas.service_manager.base.ContractCache") as mock_cache:
         instance = local_mock_config.return_value
         instance.plugins = {"olas": mock_olas_config}
         instance.save_config = MagicMock()
 
+        # Mock ContractCache to return MagicMock contracts
+        mock_cache_instance = mock_cache.return_value
+        mock_cache_instance.get_contract.return_value = MagicMock()
+
         sm = ServiceManager(mock_wallet)
         # Ensure service is properly set
         sm.service = mock_service
@@ -127,6 +132,7 @@ def service_manager(
         yield sm
 
 
+
 def test_init(service_manager):
     """Test initialization."""
     assert service_manager.registry is not None