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

iwa/plugins/olas/contracts/activity_checker.py

@@ -10,8 +10,6 @@ requests relative to the time elapsed since the last checkpoint.
 
 from typing import Tuple
 
-from web3 import Web3
-
 from iwa.core.constants import DEFAULT_MECH_CONTRACT_ADDRESS
 from iwa.core.types import EthereumAddress
 from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH, ContractInstance
@@ -70,9 +68,6 @@ class ActivityCheckerContract(ContractInstance):
     def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
         """Get the nonces for a multisig address.
 
-        This method reads directly from the source contracts to ensure fresh data
-        and compatibility with Legacy/MM contracts.
-
         Args:
             multisig: The multisig address to check.
 
@@ -82,52 +77,8 @@ class ActivityCheckerContract(ContractInstance):
                 - mech_requests_count: Total mech requests made
 
         """
-        # 1. Get Safe Nonce
-        safe_nonce = 0
-        try:
-            # Minimal ABI for Safe nonce
-            safe_abi = [{"name": "nonce", "type": "function", "inputs": [], "outputs": [{"type": "uint256"}]}]
-            safe_contract = self.chain_interface.web3._web3.eth.contract(
-                address=Web3.to_checksum_address(multisig), abi=safe_abi
-            )
-            safe_nonce = safe_contract.functions.nonce().call()
-        except Exception as e:
-            # Fallback or log error? If safe read fails, something is very wrong.
-            # But we don't want to crash the whole status check if possible.
-            # For now, let's log and keep 0 or re-raise if critical.
-            # safe_nonce is critical for liveness check (diffNonces).
-            from loguru import logger
-            logger.warning(f"Failed to read Safe nonce for {multisig}: {e}")
-
-        # 2. Get Mech Requests Count
-        mech_requests = 0
-
-        if self.mech_marketplace:
-            # Case A: Marketplace (MM)
-            try:
-                # Minimal ABI for Marketplace mapRequestCounts
-                mp_abi = [{"name": "mapRequestCounts", "type": "function", "inputs": [{"type": "address"}], "outputs": [{"type": "uint256"}]}]
-                mp_contract = self.chain_interface.web3._web3.eth.contract(
-                    address=Web3.to_checksum_address(self.mech_marketplace), abi=mp_abi
-                )
-                mech_requests = mp_contract.functions.mapRequestCounts(multisig).call()
-            except Exception as e:
-                from loguru import logger
-                logger.warning(f"Failed to read Marketplace requests for {multisig}: {e}")
-        else:
-            # Case B: Legacy (AgentMech)
-            try:
-                # Minimal ABI for AgentMech getRequestsCount
-                mech_abi = [{"name": "getRequestsCount", "type": "function", "inputs": [{"type": "address"}], "outputs": [{"type": "uint256"}]}]
-                mech_contract = self.chain_interface.web3._web3.eth.contract(
-                    address=Web3.to_checksum_address(self.agent_mech), abi=mech_abi
-                )
-                mech_requests = mech_contract.functions.getRequestsCount(multisig).call()
-            except Exception as e:
-                from loguru import logger
-                logger.warning(f"Failed to read AgentMech requests for {multisig}: {e}")
-
-        return (safe_nonce, mech_requests)
+        nonces = self.contract.functions.getMultisigNonces(multisig).call()
+        return (nonces[0], nonces[1])
 
     def is_ratio_pass(
         self,

iwa/plugins/olas/contracts/mech_marketplace_v1.py

@@ -0,0 +1,68 @@
+"""Mech Marketplace V1 contract interaction (VERSION 1.0.0).
+
+This contract version is used by older staking programs like Expert 17 MM.
+It has a different request signature than v2, requiring staking instance
+and service ID parameters for both the mech and the requester.
+
+Key differences from v2:
+- request() takes staking instance + service ID for both mech and requester
+- No payment types or balance trackers
+- No checkMech or mapPaymentTypeBalanceTrackers functions
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+
+from iwa.core.contracts.contract import ContractInstance
+from iwa.core.types import EthereumAddress
+
+
+@dataclass
+class V1RequestParams:
+    """Parameters for v1 marketplace request."""
+
+    data: bytes
+    priority_mech: str
+    priority_mech_staking_instance: str
+    priority_mech_service_id: int
+    requester_staking_instance: str
+    requester_service_id: int
+    response_timeout: int = 300
+    value: int = 10_000_000_000_000_000  # 0.01 xDAI
+
+
+class MechMarketplaceV1Contract(ContractInstance):
+    """Class to interact with the Mech Marketplace v1 contract (VERSION 1.0.0).
+
+    This is the older marketplace used by staking contracts like Expert 17 MM.
+    """
+
+    name = "mech_marketplace_v1"
+    abi_path = Path(__file__).parent / "abis" / "mech_marketplace_v1.json"
+
+    def prepare_request_tx(
+        self,
+        from_address: EthereumAddress,
+        params: V1RequestParams,
+    ) -> Optional[Dict]:
+        """Prepare a v1 marketplace request transaction.
+
+        v1 ABI: request(bytes data, address priorityMech,
+                        address priorityMechStakingInstance, uint256 priorityMechServiceId,
+                        address requesterStakingInstance, uint256 requesterServiceId,
+                        uint256 responseTimeout)
+        """
+        return self.prepare_transaction(
+            method_name="request",
+            method_kwargs={
+                "data": params.data,
+                "priorityMech": params.priority_mech,
+                "priorityMechStakingInstance": params.priority_mech_staking_instance,
+                "priorityMechServiceId": params.priority_mech_service_id,
+                "requesterStakingInstance": params.requester_staking_instance,
+                "requesterServiceId": params.requester_service_id,
+                "responseTimeout": params.response_timeout,
+            },
+            tx_params={"from": from_address, "value": params.value},
+        )

iwa/plugins/olas/scripts/test_full_mech_flow.py

@@ -173,7 +173,7 @@ def main():  # noqa: C901
     # Get contract addresses
     protocol_contracts = OLAS_CONTRACTS.get("gnosis", {})
     legacy_mech_address = protocol_contracts.get("OLAS_MECH")
-    marketplace_address = protocol_contracts.get("OLAS_MECH_MARKETPLACE")
+    marketplace_address = protocol_contracts.get("OLAS_MECH_MARKETPLACE_V2")
 
     # Step 3: Send Legacy Mech Request
     print_step("Step 3: Send Legacy Mech Request", "3️⃣")

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,17 +197,22 @@ 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()
             )
             if use_marketplace:
                 priority_mech = priority_mech or detected_priority_mech
+                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=detected_marketplace,
                 priority_mech=priority_mech,
                 max_delivery_rate=max_delivery_rate,
                 payment_type=payment_type,
@@ -204,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:
@@ -212,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:
@@ -232,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")
@@ -248,70 +336,129 @@ 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
 
+    def _resolve_marketplace_config(
+        self, marketplace_addr: Optional[str], priority_addr: Optional[str]
+    ) -> tuple[str, str]:
+        """Resolve marketplace and priority mech addresses. Returns (marketplace, priority)."""
+        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_V2")
+        if not resolved_mp:
+            raise ValueError(f"Mech Marketplace address not found for chain {chain_name}")
+
+        if not priority_addr:
+            raise ValueError("priority_mech is required for marketplace requests")
+
+        return str(resolved_mp), Web3.to_checksum_address(priority_addr)
+
+    def _prepare_marketplace_params(
+        self,
+        value: Optional[int],
+        max_delivery_rate: Optional[int],
+        payment_type: Optional[bytes],
+    ) -> tuple[int, int, bytes]:
+        """Prepare default values for marketplace parameters."""
+        p_type = payment_type or bytes.fromhex(PAYMENT_TYPE_NATIVE)
+        val = value if value is not None else 10_000_000_000_000_000
+        rate = max_delivery_rate if max_delivery_rate is not None else val
+        return val, rate, p_type
+
     def _send_marketplace_mech_request(
         self,
         data: bytes,
         value: Optional[int] = 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
 
-        multisig_address = self.service.multisig_address
-        chain_name = self.chain_name if self.service else getattr(self, "chain_name", "gnosis")
-        protocol_contracts = OLAS_CONTRACTS.get(chain_name, {})
-        marketplace_address = protocol_contracts.get("OLAS_MECH_MARKETPLACE")
-
-        if not marketplace_address:
-            logger.error(f"Mech Marketplace address not found for chain {chain_name}")
+        try:
+            marketplace_address, priority_mech = self._resolve_marketplace_config(
+                marketplace_address, priority_mech
+            )
+        except ValueError as e:
+            logger.error(e)
             return None
 
-        if not priority_mech:
-            logger.error("priority_mech is required for marketplace requests")
-            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,
+            )
 
-        priority_mech = Web3.to_checksum_address(priority_mech)
-        marketplace = MechMarketplaceContract(str(marketplace_address), chain_name=chain_name)
+        # v2 flow
+        marketplace = MechMarketplaceContract(marketplace_address, chain_name=self.chain_name)
 
         if not self._validate_priority_mech(marketplace, priority_mech):
             return None
 
-        # Set defaults for payment
-        if payment_type is None:
-            payment_type = bytes.fromhex(PAYMENT_TYPE_NATIVE)
-
-        if value is None:
-            value = 10_000_000_000_000_000
-            logger.info(f"Using default value: {value} wei (0.01 xDAI)")
-
-        if max_delivery_rate is None:
-            max_delivery_rate = value
-            logger.info(f"Using value as max_delivery_rate: {max_delivery_rate}")
+        # Set defaults for payment and delivery
+        value, max_delivery_rate, payment_type = self._prepare_marketplace_params(
+            value, max_delivery_rate, payment_type
+        )
 
         if not self._validate_marketplace_params(marketplace, response_timeout, payment_type):
             return None
 
         # Prepare transaction
         tx_data = marketplace.prepare_request_tx(
-            from_address=multisig_address,
+            from_address=self.service.multisig_address,
             request_data=data,
             priority_mech=priority_mech,
             response_timeout=response_timeout,
@@ -332,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,

iwa/tools/reset_tenderly.py

@@ -343,8 +343,8 @@ if __name__ == "__main__":  # pragma: no cover
         "-p",
         type=int,
         default=1,
-        choices=[1, 2, 3],
-        help="Tenderly profile to use (1 or 2)",
+        choices=[1, 2, 3, 4],
+        help="Tenderly profile to use (1-4)",
     )
     args = parser.parse_args()
 

{iwa-0.0.17.dist-info → iwa-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.17
+Version: 0.0.19
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown