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

iwa/plugins/olas/service_manager/mech.py

@@ -1,28 +1,57 @@
 """Mech manager mixin.
 
-This module handles sending mech requests for OLAS services. There are TWO
-distinct flows for mech requests, and the correct one MUST be used based on
-the service's staking contract:
-
-1. **Legacy Mech Flow** (use_marketplace=False):
-   - Sends requests directly to the legacy mech contract (0x77af31De...)
-   - Used by NON-MM staking contracts (e.g., "Expert X (Yk OLAS)")
-   - Activity checker calls `agentMech.getRequestsCount(multisig)` to count
-
-2. **Marketplace Flow** (use_marketplace=True):
-   - Sends requests via MechMarketplace contract (0x735FAAb1c...)
-   - Used by MM staking contracts (e.g., "Expert X MM (Yk OLAS)")
-   - Activity checker calls `mechMarketplace.mapRequestCounts(multisig)` to count
-   - Requires a priority_mech that is registered on the marketplace
-   - Default priority_mech from olas-operate-middleware: 0xC05e7412...
-
-**IMPORTANT**: If a service is staked in an MM contract but sends legacy mech
-requests, those requests will NOT be counted by the activity checker, and the
-service will not receive staking rewards.
-
-The `get_marketplace_config()` method automatically detects which flow to use
-by checking if the staking contract's activity checker has a `mechMarketplace`
-field set to a non-zero address.
+This module handles sending mech requests for OLAS services. There are THREE
+distinct flows for mech requests, and the correct one is automatically selected
+based on the service's staking contract configuration:
+
+Flow Selection Logic:
+    1. `get_marketplace_config()` checks if staking contract's activity checker
+       has a non-zero `mechMarketplace` address
+    2. If yes → marketplace request (v1 or v2 depending on address)
+    3. If no → legacy mech request
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ FLOW 1: Legacy Mech (use_marketplace=False)                                 │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Contract:    Legacy Mech (0x77af31De...)                                    │
+│ Used by:     NON-MM staking contracts (e.g., "Expert X (Yk OLAS)")          │
+│ Counting:    agentMech.getRequestsCount(multisig)                           │
+│ Method:      _send_legacy_mech_request()                                    │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ FLOW 2: Marketplace v2 (use_marketplace=True, marketplace=0x735F...)        │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Contract:    MechMarketplace v2 (0x735FAAb1c...)                            │
+│ Used by:     Newer MM staking contracts                                     │
+│ Counting:    mechMarketplace.mapRequestCounts(multisig)                     │
+│ Method:      _send_marketplace_mech_request() → MechMarketplaceContract     │
+│ Signature:   request(bytes,uint256,bytes32,address,uint256,bytes)           │
+│ Note:        Uses payment types (PAYMENT_TYPE_NATIVE)                       │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ FLOW 3: Marketplace v1 (use_marketplace=True, marketplace=0x4554...)        │
+├─────────────────────────────────────────────────────────────────────────────┤
+│ Contract:    MechMarketplace v1 (0x4554fE75...)  [VERSION 1.0.0]            │
+│ Used by:     Older MM contracts (e.g., "Expert 17 MM", trader_ant)          │
+│ Counting:    mechMarketplace.mapRequestCounts(multisig)                     │
+│ Method:      _send_v1_marketplace_request() → MechMarketplaceV1Contract     │
+│ Signature:   request(bytes,address,address,uint256,address,uint256,uint256) │
+│ Note:        Requires staking instance + service ID for mech AND requester  │
+│              No payment types - simpler but different parameter set         │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+Important:
+    If a service is staked in an MM contract but sends requests to the wrong
+    marketplace (or uses legacy flow), those requests will NOT be counted by
+    the activity checker, and the service will not receive staking rewards.
+
+The dispatch logic:
+    1. _send_marketplace_mech_request() checks if marketplace ∈ V1_MARKETPLACES
+    2. If v1 → dispatches to _send_v1_marketplace_request()
+    3. If v2 → continues with MechMarketplaceContract (v2 ABI)
+
 """
 
 from typing import Optional
@@ -37,6 +66,31 @@ from iwa.plugins.olas.constants import (
 )
 from iwa.plugins.olas.contracts.mech import MechContract
 from iwa.plugins.olas.contracts.mech_marketplace import MechMarketplaceContract
+from iwa.plugins.olas.contracts.mech_marketplace_v1 import (
+    MechMarketplaceV1Contract,
+    V1RequestParams,
+)
+
+# Maps marketplace address to (priority_mech_address, priority_mech_service_id, mech_staking_instance)
+# Source: olas-operate-middleware profiles.py and manage.py
+# The 3rd element (staking instance) is only needed for v1 marketplaces
+DEFAULT_PRIORITY_MECH = {
+    "0x4554fE75c1f5576c1d7F765B2A036c199Adae329": (
+        "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053",
+        975,
+        "0x998dEFafD094817EF329f6dc79c703f1CF18bC90",  # Mech staking instance for v1
+    ),
+    "0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB": (
+        "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
+        2182,
+        None,  # v2 doesn't need staking instance
+    ),
+}
+
+# Marketplace v1 addresses (use different request signature)
+V1_MARKETPLACES = {
+    "0x4554fE75c1f5576c1d7F765B2A036c199Adae329",  # VERSION 1.0.0
+}
 
 
 class MechManagerMixin:
@@ -72,17 +126,26 @@ class MechManagerMixin:
             checker = staking.activity_checker
 
             if checker.mech_marketplace and checker.mech_marketplace != ZERO_ADDRESS:
-                # Use the default marketplace priority mech from constants
-                from iwa.plugins.olas.constants import OLAS_CONTRACTS
-
-                protocol_contracts = OLAS_CONTRACTS.get(self.chain_name, {})
-                priority_mech = protocol_contracts.get("OLAS_MECH_MARKETPLACE_PRIORITY")
+                # Get priority mech from mapping based on marketplace address
+                marketplace_addr = Web3.to_checksum_address(checker.mech_marketplace)
+                priority_mech_info = DEFAULT_PRIORITY_MECH.get(marketplace_addr)
+
+                if priority_mech_info:
+                    priority_mech = priority_mech_info[0]  # First element is mech address
+                else:
+                    # Fallback to constants if marketplace not in mapping
+                    protocol_contracts = OLAS_CONTRACTS.get(self.chain_name, {})
+                    priority_mech = protocol_contracts.get("OLAS_MECH_MARKETPLACE_PRIORITY")
+                    logger.warning(
+                        f"[MECH] Marketplace {marketplace_addr} not in DEFAULT_PRIORITY_MECH, "
+                        f"using fallback priority_mech: {priority_mech}"
+                    )
 
                 logger.info(
                     f"[MECH] Service {self.service.service_id} requires marketplace requests "
-                    f"(marketplace={checker.mech_marketplace}, priority_mech={priority_mech})"
+                    f"(marketplace={marketplace_addr}, priority_mech={priority_mech})"
                 )
-                return (True, checker.mech_marketplace, priority_mech)
+                return (True, marketplace_addr, priority_mech)
 
             return (False, None, None)
 
@@ -134,6 +197,7 @@ class MechManagerMixin:
             return None
 
         # Auto-detect marketplace requirement if not explicitly specified
+        detected_marketplace = None
         if use_marketplace is None:
             use_marketplace, detected_marketplace, detected_priority_mech = (
                 self.get_marketplace_config()
@@ -143,10 +207,12 @@ class MechManagerMixin:
                 mech_address = mech_address or detected_marketplace
 
         if use_marketplace:
+            # Use detected marketplace if available, otherwise _send_marketplace_mech_request
+            # will fall back to constant
             return self._send_marketplace_mech_request(
                 data=data,
                 value=value,
-                marketplace_address=mech_address,
+                marketplace_address=detected_marketplace,
                 priority_mech=priority_mech,
                 max_delivery_rate=max_delivery_rate,
                 payment_type=payment_type,
@@ -206,7 +272,12 @@ class MechManagerMixin:
         )
 
     def _validate_priority_mech(self, marketplace, priority_mech: str) -> bool:
-        """Validate priority mech is registered on marketplace."""
+        """Validate priority mech is registered on marketplace.
+
+        Note: OLD marketplace v1 (0x4554...) doesn't have checkMech function.
+        In that case, we skip validation and proceed - v1 doesn't require
+        mech registration.
+        """
         try:
             mech_multisig = marketplace.call("checkMech", priority_mech)
             if mech_multisig == ZERO_ADDRESS:
@@ -214,8 +285,19 @@ class MechManagerMixin:
                 return False
             logger.debug(f"Priority mech {priority_mech} -> multisig {mech_multisig}")
         except Exception as e:
-            logger.error(f"Failed to verify priority mech registration: {e}")
-            return False
+            # Check if this is a revert (v1 doesn't have checkMech) vs a network error
+            error_str = str(e).lower()
+            if "reverted" in error_str or "execution reverted" in error_str:
+                # v1 marketplaces don't have checkMech - skip validation
+                logger.warning(
+                    f"Could not validate priority mech (marketplace may be v1): {e}. "
+                    "Proceeding without validation."
+                )
+                return True
+            else:
+                # Real error (network, timeout, etc.) - fail validation
+                logger.error(f"Failed to validate priority mech (network error?): {e}")
+                return False
 
         # Log mech factory info (optional validation)
         try:
@@ -234,7 +316,11 @@ class MechManagerMixin:
     def _validate_marketplace_params(
         self, marketplace, response_timeout: int, payment_type: bytes
     ) -> bool:
-        """Validate marketplace parameters."""
+        """Validate marketplace parameters.
+
+        Note: v1 marketplaces may not have all validation functions.
+        We proceed with warnings when validation functions are unavailable.
+        """
         # Validate response_timeout bounds
         try:
             min_timeout = marketplace.call("minResponseTimeout")
@@ -250,15 +336,31 @@ class MechManagerMixin:
         except Exception as e:
             logger.warning(f"Could not validate response_timeout bounds: {e}")
 
-        # Validate payment type has balance tracker
+        # Validate payment type has balance tracker (v2 only)
         try:
             balance_tracker = marketplace.call("mapPaymentTypeBalanceTrackers", payment_type)
             if balance_tracker == ZERO_ADDRESS:
-                logger.error(f"No balance tracker for payment type 0x{payment_type.hex()}")
+                # This is a validation failure for v2 - return False
+                logger.error(
+                    f"No balance tracker for payment type 0x{payment_type.hex()}. "
+                    "This is required for v2 marketplace requests."
+                )
                 return False
-            logger.debug(f"Payment type balance tracker: {balance_tracker}")
+            else:
+                logger.debug(f"Payment type balance tracker: {balance_tracker}")
         except Exception as e:
-            logger.warning(f"Could not validate payment type: {e}")
+            # Check if this is a revert (v1 doesn't have this function) vs a network error
+            error_str = str(e).lower()
+            if "reverted" in error_str or "execution reverted" in error_str:
+                # v1 marketplaces don't have mapPaymentTypeBalanceTrackers - skip
+                logger.warning(
+                    f"Could not validate payment type (marketplace may be v1): {e}. "
+                    "Proceeding without validation."
+                )
+            else:
+                # Real error - fail validation
+                logger.error(f"Failed to validate payment type (network error?): {e}")
+                return False
 
         return True
 
@@ -269,7 +371,7 @@ class MechManagerMixin:
         chain_name = self.chain_name if self.service else getattr(self, "chain_name", "gnosis")
         protocol_contracts = OLAS_CONTRACTS.get(chain_name, {})
 
-        resolved_mp = marketplace_addr or protocol_contracts.get("OLAS_MECH_MARKETPLACE")
+        resolved_mp = marketplace_addr or protocol_contracts.get("OLAS_MECH_MARKETPLACE_V2")
         if not resolved_mp:
             raise ValueError(f"Mech Marketplace address not found for chain {chain_name}")
 
@@ -294,14 +396,30 @@ class MechManagerMixin:
         self,
         data: bytes,
         value: Optional[int] = None,
-        marketplace_address: Optional[str] = None,
         priority_mech: Optional[str] = None,
+        marketplace_address: Optional[str] = None,
         max_delivery_rate: Optional[int] = None,
         payment_type: Optional[bytes] = None,
         payment_data: bytes = b"",
         response_timeout: int = 300,
     ) -> Optional[str]:
-        """Send a marketplace mech request with validation."""
+        """Send a marketplace mech request with validation.
+
+        Args:
+            data: Request data payload (bytes).
+            value: Native currency value to send with request (wei).
+            priority_mech: Priority mech address for request processing.
+            marketplace_address: The marketplace contract address from activity checker.
+                                 If None, falls back to OLAS_MECH_MARKETPLACE_V2 constant.
+            max_delivery_rate: Maximum delivery rate for the mech.
+            payment_type: Payment type bytes32 (defaults to PAYMENT_TYPE_NATIVE).
+            payment_data: Additional payment data.
+            response_timeout: Timeout for response in seconds.
+
+        Returns:
+            Transaction hash if successful, None otherwise.
+
+        """
         if not self.service:
             logger.error("No active service")
             return None
@@ -314,6 +432,17 @@ class MechManagerMixin:
             logger.error(e)
             return None
 
+        # Dispatch to v1 handler if marketplace is v1
+        if marketplace_address in V1_MARKETPLACES:
+            return self._send_v1_marketplace_request(
+                data=data,
+                marketplace_address=marketplace_address,
+                priority_mech=priority_mech,
+                response_timeout=response_timeout,
+                value=value,
+            )
+
+        # v2 flow
         marketplace = MechMarketplaceContract(marketplace_address, chain_name=self.chain_name)
 
         if not self._validate_priority_mech(marketplace, priority_mech):
@@ -350,6 +479,77 @@ class MechManagerMixin:
             expected_event="MarketplaceRequest",
         )
 
+    def _send_v1_marketplace_request(
+        self,
+        data: bytes,
+        marketplace_address: str,
+        priority_mech: str,
+        response_timeout: int = 300,
+        value: Optional[int] = None,
+    ) -> Optional[str]:
+        """Send a v1 marketplace mech request.
+
+        v1 marketplace (VERSION 1.0.0) requires staking instance and service ID
+        for both the mech and the requester, unlike v2 which uses payment types.
+        """
+        if not self.service:
+            logger.error("No active service")
+            return None
+
+        # Get mech info from DEFAULT_PRIORITY_MECH (now a 3-tuple)
+        mech_info = DEFAULT_PRIORITY_MECH.get(marketplace_address)
+        if not mech_info or len(mech_info) < 3:
+            logger.error(f"No priority mech info for v1 marketplace {marketplace_address}")
+            return None
+
+        priority_mech_address, priority_mech_service_id, priority_mech_staking = mech_info
+
+        if not priority_mech_staking:
+            logger.error(f"No mech staking instance for v1 marketplace {marketplace_address}")
+            return None
+
+        # Get requester staking info from current service
+        requester_staking_instance = self.service.staking_contract_address
+        requester_service_id = self.service.service_id
+
+        if not requester_staking_instance:
+            logger.error("No staking contract for current service (required for v1)")
+            return None
+
+        # Build v1 request params
+        params = V1RequestParams(
+            data=data,
+            priority_mech=priority_mech_address,
+            priority_mech_staking_instance=priority_mech_staking,
+            priority_mech_service_id=priority_mech_service_id,
+            requester_staking_instance=requester_staking_instance,
+            requester_service_id=requester_service_id,
+            response_timeout=response_timeout,
+            value=value or 10_000_000_000_000_000,  # 0.01 xDAI default
+        )
+
+        logger.info(
+            f"[MECH-V1] Sending v1 marketplace request to {marketplace_address} "
+            f"(mech={priority_mech_address}, mech_svc={priority_mech_service_id})"
+        )
+
+        marketplace = MechMarketplaceV1Contract(marketplace_address, chain_name=self.chain_name)
+        tx_data = marketplace.prepare_request_tx(
+            from_address=self.service.multisig_address,
+            params=params,
+        )
+
+        if not tx_data:
+            logger.error("Failed to prepare v1 marketplace request transaction")
+            return None
+
+        return self._execute_mech_tx(
+            tx_data=tx_data,
+            to_address=str(marketplace_address),
+            contract_instance=marketplace,
+            expected_event="MarketplaceRequest",
+        )
+
     def _execute_mech_tx(
         self,
         tx_data: dict,
@@ -412,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",