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

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/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_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

iwa/plugins/olas/tests/test_service_manager_errors.py

@@ -23,12 +23,19 @@ def mock_wallet():
     return wallet
 
 
-def setup_manager(mock_wallet):
+@pytest.fixture
+def mock_manager(mock_wallet):
     """Setup a ServiceManager with mocked dependencies."""
-    with patch("iwa.plugins.olas.service_manager.base.Config") as mock_cfg_cls:
+    with patch("iwa.plugins.olas.service_manager.base.Config") as mock_cfg_cls, \
+         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)
+
         mock_cfg = mock_cfg_cls.return_value
         mock_cfg.plugins = {"olas": MagicMock()}
         mock_cfg.plugins["olas"].get_service.return_value = None
+
         with patch(
             "iwa.plugins.olas.service_manager.OLAS_CONTRACTS",
             {
@@ -43,18 +50,22 @@ def setup_manager(mock_wallet):
                 mock_if = mock_if_cls.return_value
                 mock_if.get.return_value.chain.name.lower.return_value = "gnosis"
                 mock_if.get.return_value.get_contract_address.return_value = VALID_ADDR
+
                 manager = ServiceManager(mock_wallet)
                 manager.registry = MagicMock()
                 manager.manager_contract = MagicMock()
                 manager.olas_config = mock_cfg.plugins["olas"]
                 manager.chain_name = "gnosis"
+                # Fix recursive mock issue by setting explicit return value
+                manager.registry.chain_interface = MagicMock()
                 manager.registry.chain_interface.get_contract_address.return_value = VALID_ADDR
-                return manager
+
+                yield manager
 
 
-def test_service_manager_mech_requests_failures(mock_wallet):
+def test_service_manager_mech_requests_failures(mock_manager):
     """Test failure paths in mech requests."""
-    manager = setup_manager(mock_wallet)
+    manager = mock_manager
 
     # Service missing
     manager.service = None
@@ -99,9 +110,9 @@ def test_service_manager_mech_requests_failures(mock_wallet):
         assert manager.send_mech_request(b"data", use_marketplace=False) is None
 
 
-def test_service_manager_lifecycle_failures(mock_wallet):
+def test_service_manager_lifecycle_failures(mock_manager, mock_wallet):
     """Test failure paths in lifecycle methods."""
-    manager = setup_manager(mock_wallet)
+    manager = mock_manager
     manager.service = Service(service_name="t", chain_name="gnosis", service_id=1, agent_ids=[1])
 
     # register_agent failures
@@ -147,9 +158,9 @@ def test_service_manager_lifecycle_failures(mock_wallet):
     assert manager.wind_down() is True
 
 
-def test_service_manager_staking_status_failures(mock_wallet):
+def test_service_manager_staking_status_failures(mock_manager):
     """Test failure paths in get_staking_status."""
-    manager = setup_manager(mock_wallet)
+    manager = mock_manager
 
     # Service missing
     manager.service = None
@@ -178,9 +189,9 @@ def test_service_manager_staking_status_failures(mock_wallet):
         assert status.mech_requests_this_epoch == 0
 
 
-def test_service_manager_verify_event_exception(mock_wallet):
+def test_service_manager_verify_event_exception(mock_manager):
     """Test exception path in _execute_mech_tx."""
-    manager = setup_manager(mock_wallet)
+    manager = mock_manager
     manager.service = Service(
         service_name="t",
         chain_name="gnosis",

iwa/plugins/olas/tests/test_service_manager_flows.py

@@ -45,10 +45,12 @@ def mock_config():
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
 def test_create_service_success(
-    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test successful service creation."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     # Setup Config with new OlasConfig structure
     mock_config_inst = mock_config_cls.return_value
     mock_olas_config = MagicMock()
@@ -84,10 +86,12 @@ def test_create_service_success(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
 def test_create_service_failures(
-    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test service creation failure modes."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     mock_config_inst = mock_config_cls.return_value
     mock_olas_config = MagicMock()
     mock_olas_config.get_service.return_value = None
@@ -139,10 +143,12 @@ def test_create_service_failures(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
 def test_create_service_with_approval(
-    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test service creation with token approval."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     mock_config_inst = mock_config_cls.return_value
     mock_olas_config = MagicMock()
     mock_olas_config.get_service.return_value = None
@@ -170,10 +176,12 @@ def test_create_service_with_approval(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
 def test_activate_registration(
-    mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
+    mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet
 ):
     """Test service registration activation."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     mock_config_inst = mock_config_cls.return_value
     mock_olas_config = MagicMock()
     mock_service = MagicMock()
@@ -228,8 +236,10 @@ def test_activate_registration(
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-def test_register_agent(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
+def test_register_agent(mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
     """Test agent registration flow."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     mock_config_inst = mock_config_cls.return_value
     mock_olas_config = MagicMock()
     mock_service = MagicMock()
@@ -277,8 +287,10 @@ def test_register_agent(mock_sm_contract, mock_registry_contract, mock_config_cl
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-def test_deploy(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
+def test_deploy(mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
     """Test service deployment."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     # Setup mock service
     mock_service = MagicMock()
     mock_service.service_id = 123
@@ -341,8 +353,10 @@ def test_deploy(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_
 @patch("iwa.plugins.olas.service_manager.base.Config")
 @patch("iwa.plugins.olas.service_manager.base.ServiceRegistryContract")
 @patch("iwa.plugins.olas.service_manager.base.ServiceManagerContract")
-def test_terminate(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
+def test_terminate(mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
     """Test service termination."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     # Setup mock service
     mock_service = MagicMock()
     mock_service.service_id = 123
@@ -401,8 +415,10 @@ def test_terminate(mock_sm_contract, mock_registry_contract, mock_config_cls, mo
 @patch(
     "iwa.plugins.olas.service_manager.base.ServiceManagerContract"
 )  # MUST mock specifically here
-def test_stake(mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
+@patch("iwa.plugins.olas.service_manager.base.ContractCache")
+def test_stake(mock_cache, mock_sm_contract, mock_registry_contract, mock_config_cls, mock_wallet):
     """Test service staking."""
+    mock_cache.return_value.get_contract.side_effect = lambda cls, *a, **k: cls(*a, **k)
     # Setup mock service
     mock_service = MagicMock()
     mock_service.service_id = 123