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

iwa/plugins/olas/contracts/activity_checker.py

@@ -8,7 +8,7 @@ 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 typing import Optional, Tuple
 
 from iwa.core.constants import DEFAULT_MECH_CONTRACT_ADDRESS
 from iwa.core.types import EthereumAddress
@@ -43,27 +43,11 @@ class ActivityCheckerContract(ContractInstance):
         """
         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
+        # Cache for lazy loading
+        self._mech_marketplace: Optional[EthereumAddress] = None
+        self._agent_mech: Optional[EthereumAddress] = None
+        self._liveness_ratio: Optional[int] = None
+
 
     def get_multisig_nonces(self, multisig: EthereumAddress) -> Tuple[int, int]:
         """Get the nonces for a multisig address.
@@ -80,6 +64,41 @@ class ActivityCheckerContract(ContractInstance):
         nonces = self.contract.functions.getMultisigNonces(multisig).call()
         return (nonces[0], nonces[1])
 
+
+    @property
+    def mech_marketplace(self) -> Optional[EthereumAddress]:
+        """Get the mech marketplace address."""
+        if self._mech_marketplace is None:
+            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
+        return self._mech_marketplace
+
+    @property
+    def agent_mech(self) -> EthereumAddress:
+        """Get the agent mech address."""
+        if self._agent_mech is None:
+            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
+        return self._agent_mech
+
+    @property
+    def liveness_ratio(self) -> int:
+        """Get the liveness ratio."""
+        if self._liveness_ratio is None:
+            try:
+                self._liveness_ratio = self.contract.functions.livenessRatio().call()
+            except Exception:
+                self._liveness_ratio = 0
+        return self._liveness_ratio
+
     def is_ratio_pass(
         self,
         current_nonces: Tuple[int, int],
@@ -101,6 +120,25 @@ class ActivityCheckerContract(ContractInstance):
             True if liveness requirements are met.
 
         """
-        return self.contract.functions.isRatioPass(
-            list(current_nonces), list(last_nonces), ts_diff
-        ).call()
+        # Optimized implementation to avoid RPC call
+        current_safe, current_requests = current_nonces
+        last_safe, last_requests = last_nonces
+
+        diff_safe = current_safe - last_safe
+        diff_requests = current_requests - last_requests
+
+        # 1. Check if requests exceed transactions (impossible in valid operation)
+        # Also check for negative diffs (data corruption/stale data edge case)
+        if diff_requests > diff_safe or diff_requests < 0 or diff_safe < 0:
+            return False
+
+        # 2. Check time difference validity
+        if ts_diff == 0:
+            return False
+
+        # 3. Check ratio
+        # ratio = (diffRequests * 1e18) / ts_diff >= livenessRatio
+        # We use integer arithmetic as per Solidity
+        ratio = (diff_requests * 10**18) // ts_diff
+
+        return ratio >= self.liveness_ratio

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/contracts/staking.py

@@ -79,22 +79,9 @@ class StakingContract(ContractInstance):
         self.chain_name = chain_name
         self._contract_params_cache: Dict[str, int] = {}
 
-        # Get activity checker from the staking contract
-        activity_checker_address = self.call("activityChecker")
-        self.activity_checker = ActivityCheckerContract(
-            activity_checker_address, chain_name=chain_name
-        )
-        self.activity_checker_address = activity_checker_address
-
-        # Cache contract parameters
-        self.available_rewards = self.call("availableRewards")
-        self.balance = self.call("balance")
-        self.liveness_period = self.call("livenessPeriod")
-        self.rewards_per_second = self.call("rewardsPerSecond")
-        self.max_num_services = self.call("maxNumServices")
-        self.min_staking_deposit = self.call("minStakingDeposit")
-        self.min_staking_duration_hours = self.call("minStakingDuration") / 3600
-        self.staking_token_address = self.call("stakingToken")
+        self._activity_checker: Optional[ActivityCheckerContract] = None
+        self._activity_checker_address: Optional[EthereumAddress] = None
+
 
     def get_requirements(self) -> Dict[str, Union[str, int]]:
         """Get the contract requirements for token and deposits.
@@ -193,10 +180,16 @@ class StakingContract(ContractInstance):
         remaining_seconds = (epoch_end - datetime.now(timezone.utc)).total_seconds()
 
         # Check liveness ratio using activity checker
+        # logic: use the latest of (service_start_time, global_checkpoint_time)
+        # If service started AFTER global checkpoint, use service_start_time.
+        # If service was already running, use global_checkpoint_time.
+        global_ts_checkpoint = self.ts_checkpoint()
+        effective_ts_start = max(ts_start, global_ts_checkpoint)
+
         liveness_passed = self.is_liveness_ratio_passed(
             current_nonces=current_nonces,
             last_nonces=(last_safe_nonce, last_mech_requests),
-            ts_start=ts_start,
+            ts_start=effective_ts_start,
         )
 
         return {
@@ -223,8 +216,36 @@ class StakingContract(ContractInstance):
         return StakingState(self.call("getStakingState", service_id))
 
     def ts_checkpoint(self) -> int:
-        """Get the timestamp of the last checkpoint."""
-        return self.call("tsCheckpoint")
+        """Get the timestamp of the last checkpoint.
+
+        Cached until the estimated end of the current epoch (ts_checkpoint + liveness_period).
+        """
+        now = time.time()
+        cache_key = "ts_checkpoint"
+
+        # Check if we have a valid cached value
+        if cache_key in self._contract_params_cache:
+            ts = self._contract_params_cache[cache_key]
+            # Use liveness period to determine if we should re-check
+            if now < ts + self.liveness_period:
+                return ts
+
+            # If past expected epoch end, check at most once per minute
+            last_checked = self._contract_params_cache.get(f"{cache_key}_last_checked", 0)
+            if now - last_checked < 60:
+                return ts
+
+        # Fetch new value
+        ts = self.call("tsCheckpoint")
+        self._contract_params_cache[cache_key] = ts
+        self._contract_params_cache[f"{cache_key}_last_checked"] = now
+        return ts
+
+    def clear_epoch_cache(self) -> None:
+        """Clear cache for epoch-dependent properties."""
+        self._contract_params_cache.pop("ts_checkpoint", None)
+        self._contract_params_cache.pop("ts_checkpoint_last_checked", None)
+        logger.debug(f"Cleared epoch cache for StakingContract {self.address}")
 
     def get_required_requests(self, use_liveness_period: bool = True) -> int:
         """Calculate the required requests for the current epoch.
@@ -246,6 +267,81 @@ class StakingContract(ContractInstance):
             (time_diff * self.activity_checker.liveness_ratio) / 1e18 + requests_safety_margin
         )
 
+    @property
+    def activity_checker_address_value(self) -> EthereumAddress:
+        """Get the activity checker address."""
+        if self._activity_checker_address is None:
+            self._activity_checker_address = self.call("activityChecker")
+        return self._activity_checker_address
+
+    @property
+    def activity_checker_address(self) -> EthereumAddress:
+        """Backwards compatibility for activity_checker_address."""
+        return self.activity_checker_address_value
+
+    @property
+    def activity_checker(self) -> ActivityCheckerContract:
+        """Get the activity checker contract."""
+        if self._activity_checker is None:
+            self._activity_checker = ActivityCheckerContract(
+                self.activity_checker_address_value, chain_name=self.chain_name
+            )
+        return self._activity_checker
+
+    @property
+    def available_rewards(self) -> int:
+        """Get available rewards."""
+        if "availableRewards" not in self._contract_params_cache:
+            self._contract_params_cache["availableRewards"] = self.call("availableRewards")
+        return self._contract_params_cache["availableRewards"]
+
+    @property
+    def balance(self) -> int:
+        """Get contract balance."""
+        if "balance" not in self._contract_params_cache:
+            self._contract_params_cache["balance"] = self.call("balance")
+        return self._contract_params_cache["balance"]
+
+    @property
+    def liveness_period(self) -> int:
+        """Get liveness period."""
+        if "livenessPeriod" not in self._contract_params_cache:
+            self._contract_params_cache["livenessPeriod"] = self.call("livenessPeriod")
+        return self._contract_params_cache["livenessPeriod"]
+
+    @property
+    def rewards_per_second(self) -> int:
+        """Get rewards per second."""
+        if "rewardsPerSecond" not in self._contract_params_cache:
+            self._contract_params_cache["rewardsPerSecond"] = self.call("rewardsPerSecond")
+        return self._contract_params_cache["rewardsPerSecond"]
+
+    @property
+    def max_num_services(self) -> int:
+        """Get max number of services."""
+        if "maxNumServices" not in self._contract_params_cache:
+            self._contract_params_cache["maxNumServices"] = self.call("maxNumServices")
+        return self._contract_params_cache["maxNumServices"]
+
+    @property
+    def min_staking_deposit(self) -> int:
+        """Get min staking deposit."""
+        if "minStakingDeposit" not in self._contract_params_cache:
+            self._contract_params_cache["minStakingDeposit"] = self.call("minStakingDeposit")
+        return self._contract_params_cache["minStakingDeposit"]
+
+    @property
+    def min_staking_duration_hours(self) -> float:
+        """Get min staking duration in hours."""
+        return self.min_staking_duration / 3600
+
+    @property
+    def staking_token_address(self) -> EthereumAddress:
+        """Get staking token address."""
+        if "stakingToken" not in self._contract_params_cache:
+            self._contract_params_cache["stakingToken"] = self.call("stakingToken")
+        return self._contract_params_cache["stakingToken"]
+
     def is_liveness_ratio_passed(
         self,
         current_nonces: tuple,

iwa/plugins/olas/events.py

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

iwa/plugins/olas/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/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}")