iwa 0.0.15__tar.gz → 0.0.17__tar.gz

{iwa-0.0.15/src/iwa.egg-info → iwa-0.0.17}/PKG-INFO

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

{iwa-0.0.15 → iwa-0.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.15"
+version = "0.0.17"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -71,7 +71,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.0.15"
+target-version = "0.0.17"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.15 → iwa-0.0.17}/src/iwa/plugins/olas/constants.py

@@ -51,11 +51,21 @@ OLAS_CONTRACTS: Dict[str, Dict[str, EthereumAddress]] = {
             "0xa45E64d13A30a51b91ae0eb182e88a40e9b18eD8"
         ),
         "OLAS_SERVICE_MANAGER": EthereumAddress("0x068a4f0946cF8c7f9C1B58a3b5243Ac8843bf473"),
-        # Legacy mech - used by TRADER staking contracts for liveness
+        # Legacy mech - used by NON-MM TRADER staking contracts (e.g., "Expert X (Yk OLAS)")
+        # Activity checker calls agentMech.getRequestsCount(multisig) to count requests.
         "OLAS_MECH": EthereumAddress("0x77af31De935740567Cf4fF1986D04B2c964A786a"),
-        # NEW Marketplace (v2) - no staking support yet
+        # NEW Marketplace (v2) - used by MM staking contracts (e.g., "Expert X MM (Yk OLAS)")
+        # Services staked in "Expert X MM" contracts MUST use marketplace requests.
+        # Legacy mech requests will NOT be counted by the activity checker.
         "OLAS_MECH_MARKETPLACE": EthereumAddress("0x735FAAb1c4Ec41128c367AFb5c3baC73509f70bB"),
-        # OLD Marketplace (v1) - used by Pearl Beta Mech Marketplace staking
+        # Default priority mech for marketplace requests (from olas-operate-middleware)
+        # This is the mech that will process requests sent via the marketplace.
+        # Source: https://github.com/valory-xyz/olas-operate-middleware/blob/main/operate/ledger/profiles.py
+        # DEFAULT_PRIORITY_MECH["0x735FAAb1c..."] = ("0xC05e7412...", 2182)
+        "OLAS_MECH_MARKETPLACE_PRIORITY": EthereumAddress(
+            "0xC05e7412439bD7e91730a6880E18d5D5873F632C"
+        ),
+        # OLD Marketplace (v1) - legacy, kept for reference
         "OLAS_MECH_MARKETPLACE_OLD": EthereumAddress("0x4554fE75c1f5576c1d7F765B2A036c199Adae329"),
     },
     "ethereum": {

iwa-0.0.17/src/iwa/plugins/olas/contracts/activity_checker.py

@@ -0,0 +1,155 @@
+"""Activity checker contract interaction.
+
+The MechActivityChecker contract tracks liveness for staked services by monitoring:
+- Safe multisig transaction nonces
+- Mech request counts
+
+The liveness check (isRatioPass) verifies that the service is making enough mech
+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
+
+
+class ActivityCheckerContract(ContractInstance):
+    """Class to interact with the MechActivityChecker contract.
+
+    This contract tracks mech request activity for staked services and determines
+    if they meet the liveness requirements for staking rewards.
+
+    The getMultisigNonces() function returns an array with two values:
+        - nonces[0]: Safe multisig nonce (total transaction count)
+        - nonces[1]: Mech requests count (from AgentMech.getRequestsCount)
+
+    The isRatioPass() function checks if:
+        1. diffRequestsCounts <= diffNonces (requests can't exceed txs)
+        2. ratio = (diffRequestsCounts * 1e18) / time >= livenessRatio
+    """
+
+    name = "activity_checker"
+    abi_path = OLAS_ABI_PATH / "activity_checker.json"
+
+    def __init__(self, address: EthereumAddress, chain_name: str = "gnosis"):
+        """Initialize ActivityCheckerContract.
+
+        Args:
+            address: The activity checker contract address.
+            chain_name: The chain name (default: gnosis).
+
+        """
+        super().__init__(address, chain_name=chain_name)
+
+        # Check for marketplace-aware checker
+        try:
+            mech_mp_function = getattr(self.contract.functions, "mechMarketplace", None)
+            self.mech_marketplace = mech_mp_function().call() if mech_mp_function else None
+        except Exception:
+            self.mech_marketplace = None
+
+        # Get the mech address this checker tracks (legacy or priority mech)
+        try:
+            agent_mech_function = getattr(self.contract.functions, "agentMech", None)
+            self.agent_mech = (
+                agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
+            )
+        except Exception:
+            self.agent_mech = DEFAULT_MECH_CONTRACT_ADDRESS
+
+        # Get liveness ratio (requests per second * 1e18)
+        try:
+            self.liveness_ratio = self.contract.functions.livenessRatio().call()
+        except Exception:
+            self.liveness_ratio = 0
+
+    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.
+
+        Returns:
+            Tuple of (safe_nonce, mech_requests_count):
+                - safe_nonce: Total Safe transaction count
+                - 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)
+
+    def is_ratio_pass(
+        self,
+        current_nonces: Tuple[int, int],
+        last_nonces: Tuple[int, int],
+        ts_diff: int,
+    ) -> bool:
+        """Check if the liveness ratio requirement is passed.
+
+        The formula checks:
+        1. diffRequestsCounts <= diffNonces (mech requests can't exceed total txs)
+        2. ratio = (diffRequestsCounts * 1e18) / ts_diff >= livenessRatio
+
+        Args:
+            current_nonces: Current (safe_nonce, mech_requests_count).
+            last_nonces: Nonces at last checkpoint (safe_nonce, mech_requests_count).
+            ts_diff: Time difference in seconds since last checkpoint.
+
+        Returns:
+            True if liveness requirements are met.
+
+        """
+        return self.contract.functions.isRatioPass(
+            list(current_nonces), list(last_nonces), ts_diff
+        ).call()

{iwa-0.0.15 → iwa-0.0.17}/src/iwa/plugins/olas/service_manager/mech.py

@@ -1,4 +1,29 @@
-"""Mech manager mixin."""
+"""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.
+"""
 
 from typing import Optional
 
@@ -17,12 +42,60 @@ from iwa.plugins.olas.contracts.mech_marketplace import MechMarketplaceContract
 class MechManagerMixin:
     """Mixin for Mech interactions."""
 
+    def get_marketplace_config(self) -> tuple:
+        """Check if current service requires marketplace mech requests.
+
+        Queries the staking contract's activityChecker to determine if it
+        tracks marketplace requests.
+
+        Returns:
+            Tuple of (use_marketplace, marketplace_address, priority_mech):
+                - use_marketplace: True if marketplace requests are required.
+                - marketplace_address: Address of the mech marketplace (if applicable).
+                - priority_mech: Address of the priority mech (if applicable).
+
+        """
+        from iwa.core.constants import ZERO_ADDRESS
+
+        if not self.service or not self.service.staking_contract_address:
+            return (False, None, None)
+
+        try:
+            # Get staking contract with its activity checker
+            from iwa.plugins.olas.contracts.staking import StakingContract
+
+            staking = StakingContract(
+                self.service.staking_contract_address, chain_name=self.chain_name
+            )
+
+            # StakingContract has activity_checker attribute set in __init__
+            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")
+
+                logger.info(
+                    f"[MECH] Service {self.service.service_id} requires marketplace requests "
+                    f"(marketplace={checker.mech_marketplace}, priority_mech={priority_mech})"
+                )
+                return (True, checker.mech_marketplace, priority_mech)
+
+            return (False, None, None)
+
+        except Exception as e:
+            logger.debug(f"[MECH] Failed to detect marketplace config: {e}")
+            return (False, None, None)
+
     def send_mech_request(
         self,
         data: bytes,
         value: Optional[int] = None,
         mech_address: Optional[str] = None,
-        use_marketplace: bool = False,
+        use_marketplace: Optional[bool] = None,
         use_new_abi: bool = False,
         priority_mech: Optional[str] = None,
         max_delivery_rate: Optional[int] = None,
@@ -37,6 +110,7 @@ class MechManagerMixin:
             value: Payment value in wei. For marketplace, should match mech's maxDeliveryRate.
             mech_address: Address of the Mech contract (for legacy/direct flow).
             use_marketplace: Whether to use the Mech Marketplace flow.
+                             If None, auto-detects based on staking contract.
             use_new_abi: Whether to use new ABI for legacy flow.
             priority_mech: Priority mech address (required for marketplace).
             max_delivery_rate: Max delivery rate in wei (for marketplace). If None, uses value.
@@ -59,6 +133,14 @@ class MechManagerMixin:
             logger.error(f"Service {service_id} has no multisig address")
             return None
 
+        # Auto-detect marketplace requirement if not explicitly specified
+        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
+
         if use_marketplace:
             return self._send_marketplace_mech_request(
                 data=data,

{iwa-0.0.15 → iwa-0.0.17/src/iwa.egg-info}/PKG-INFO

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

iwa-0.0.15/src/iwa/plugins/olas/contracts/activity_checker.py

@@ -1,93 +0,0 @@
-"""Activity checker contract interaction.
-
-The MechActivityChecker contract tracks liveness for staked services by monitoring:
-- Safe multisig transaction nonces
-- Mech request counts
-
-The liveness check (isRatioPass) verifies that the service is making enough mech
-requests relative to the time elapsed since the last checkpoint.
-"""
-
-from typing import Tuple
-
-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
-
-
-class ActivityCheckerContract(ContractInstance):
-    """Class to interact with the MechActivityChecker contract.
-
-    This contract tracks mech request activity for staked services and determines
-    if they meet the liveness requirements for staking rewards.
-
-    The getMultisigNonces() function returns an array with two values:
-        - nonces[0]: Safe multisig nonce (total transaction count)
-        - nonces[1]: Mech requests count (from AgentMech.getRequestsCount)
-
-    The isRatioPass() function checks if:
-        1. diffRequestsCounts <= diffNonces (requests can't exceed txs)
-        2. ratio = (diffRequestsCounts * 1e18) / time >= livenessRatio
-    """
-
-    name = "activity_checker"
-    abi_path = OLAS_ABI_PATH / "activity_checker.json"
-
-    def __init__(self, address: EthereumAddress, chain_name: str = "gnosis"):
-        """Initialize ActivityCheckerContract.
-
-        Args:
-            address: The activity checker contract address.
-            chain_name: The chain name (default: gnosis).
-
-        """
-        super().__init__(address, chain_name=chain_name)
-
-        # Get the mech address this checker tracks
-        agent_mech_function = getattr(self.contract.functions, "agentMech", None)
-        self.agent_mech = (
-            agent_mech_function().call() if agent_mech_function else DEFAULT_MECH_CONTRACT_ADDRESS
-        )
-
-        # Get liveness ratio (requests per second * 1e18)
-        self.liveness_ratio = self.contract.functions.livenessRatio().call()
-
-    def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
-        """Get the nonces for a multisig address.
-
-        Args:
-            multisig: The multisig address to check.
-
-        Returns:
-            Tuple of (safe_nonce, mech_requests_count):
-                - safe_nonce: Total Safe transaction count
-                - mech_requests_count: Total mech requests made
-
-        """
-        nonces = self.contract.functions.getMultisigNonces(multisig).call()
-        return (nonces[0], nonces[1])
-
-    def is_ratio_pass(
-        self,
-        current_nonces: Tuple[int, int],
-        last_nonces: Tuple[int, int],
-        ts_diff: int,
-    ) -> bool:
-        """Check if the liveness ratio requirement is passed.
-
-        The formula checks:
-        1. diffRequestsCounts <= diffNonces (mech requests can't exceed total txs)
-        2. ratio = (diffRequestsCounts * 1e18) / ts_diff >= livenessRatio
-
-        Args:
-            current_nonces: Current (safe_nonce, mech_requests_count).
-            last_nonces: Nonces at last checkpoint (safe_nonce, mech_requests_count).
-            ts_diff: Time difference in seconds since last checkpoint.
-
-        Returns:
-            True if liveness requirements are met.
-
-        """
-        return self.contract.functions.isRatioPass(
-            list(current_nonces), list(last_nonces), ts_diff
-        ).call()