iwa 0.0.2__py3-none-any.whl → 0.0.11__py3-none-any.whl

iwa/plugins/olas/service_manager/mech.py

@@ -296,7 +296,7 @@ class MechManagerMixin:
                 chain_name=self.chain_name,
                 tags=["olas_mech_request"],
             )
-            tx_hash = receipt.get("transactionHash").hex() if success else None
+            tx_hash = Web3.to_hex(receipt.get("transactionHash")) if success else None
 
         if not tx_hash:
             logger.error("Failed to send mech request transaction")

iwa/plugins/olas/service_manager/staking.py

@@ -1,4 +1,48 @@
-"""Staking manager mixin."""
+"""Staking manager mixin for OLAS service staking operations.
+
+OLAS Token Flow Overview
+========================
+
+For OLAS token-bonded services (e.g., Expert 7 MM requiring 10,000 OLAS total),
+the tokens flow through multiple stages:
+
+1. CREATE SERVICE
+   - Service is registered on-chain with bond parameters
+   - Service Owner approves Token Utility to spend OLAS (2 × bond)
+   - NO OLAS tokens move yet
+
+2. ACTIVATION (min_staking_deposit = 5,000 OLAS for 10k contract)
+   - Service Owner approves Token Utility for the security deposit
+   - TX sends 1 wei native value (not 5k OLAS!)
+   - Token Utility internally calls transferFrom() to move 5k OLAS
+   - 5k OLAS moves: Service Owner → Token Utility
+
+3. REGISTRATION (agent_bond = 5,000 OLAS for 10k contract)
+   - Service Owner approves Token Utility for the bond amount
+   - TX sends 1 wei native value per agent (not 5k OLAS!)
+   - Token Utility internally calls transferFrom() to move 5k OLAS
+   - 5k OLAS moves: Service Owner → Token Utility
+
+4. DEPLOY
+   - Creates the Safe multisig for the service
+   - NO OLAS tokens move
+
+5. STAKE (this module) ★
+   - Only the Service NFT is approved to the staking contract
+   - NO OLAS tokens move in this transaction!
+   - The staking contract reads the deposited amounts from Token Utility
+   - Service Registry L2 token (NFT) moves: Owner → Staking Contract
+
+Key Insight:
+    At stake time, the Service Owner's OLAS balance is 0 (all 10k was deposited
+    during activation + registration). This is correct! The staking contract
+    pulls position data from the Token Utility, not from the owner's wallet.
+
+Contract Addresses (Gnosis):
+    - Token Utility: 0xa45E...8eD8
+    - Service Registry L2: 0x9338...55fD
+    - OLAS Token: 0xcE11...d9f
+"""
 
 from datetime import datetime, timezone
 from typing import Optional
@@ -6,14 +50,28 @@ from typing import Optional
 from loguru import logger
 from web3 import Web3
 
-from iwa.core.contracts.erc20 import ERC20Contract
 from iwa.core.types import EthereumAddress
+from iwa.core.utils import get_tx_hash
 from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
 from iwa.plugins.olas.models import StakingStatus
 
 
 class StakingManagerMixin:
-    """Mixin for staking operations."""
+    """Mixin for staking operations on OLAS services.
+
+    This mixin handles the final step of the service lifecycle: staking a
+    deployed service into a staking contract to earn OLAS rewards.
+
+    Important: By the time stake() is called, all OLAS tokens have already
+    been deposited to the Token Utility during activation and registration.
+    The stake transaction only transfers the Service NFT, not OLAS tokens.
+
+    Staking Requirements:
+        - Service must be in DEPLOYED state
+        - Service must be created with OLAS token (not native currency)
+        - Staking contract must have available slots
+        - Service token must match staking contract's required token
+    """
 
     def get_staking_status(self) -> Optional[StakingStatus]:
         """Get comprehensive staking status for the active service.
@@ -153,20 +211,28 @@ class StakingManagerMixin:
     def stake(self, staking_contract) -> bool:
         """Stake the service in a staking contract.
 
-        Token Flow:
-            The total OLAS required is split 50/50 between deposit and bond:
-            - minStakingDeposit: Transferred to staking contract during this call
-            - agentBond: Already in Token Utility from service registration
-
-            Example for Hobbyist 1 (100 OLAS total):
-            - minStakingDeposit: 50 OLAS (from master account -> staking contract)
-            - agentBond: 50 OLAS (already in Token Utility)
-
-        Requirements:
-            - Service must be in DEPLOYED state
-            - Service must be created with OLAS token (not native currency)
-            - Master account must have >= minStakingDeposit OLAS tokens
-            - Staking contract must have available slots
+        This is the final step after create → activate → register → deploy.
+        At this point, all OLAS tokens are already in the Token Utility.
+
+        Token Flow at Stake Time:
+            ┌─────────────────────────────────────────────────────────────────┐
+            │  What Moves:                                                    │
+            │    • Service NFT (ERC-721): Owner → Staking Contract            │
+            │                                                                 │
+            │  What does NOT Move:                                            │
+            │    • OLAS tokens - already in Token Utility from earlier steps  │
+            └─────────────────────────────────────────────────────────────────┘
+
+        Why no OLAS transfer?
+            The staking contract reads the service's bond/deposit from the
+            Token Utility contract. It doesn't need a new transfer - it just
+            verifies the amounts are sufficient and locks the service.
+
+        Process:
+            1. Validate requirements (state, token, slots)
+            2. Approve Service NFT to staking contract
+            3. Call stake(serviceId) on staking contract
+            4. Verify ServiceStaked event
 
         Args:
             staking_contract: StakingContract instance to stake in.
@@ -175,92 +241,172 @@ class StakingManagerMixin:
             True if staking succeeded, False otherwise.
 
         """
+        logger.info("=" * 50)
+        logger.info(f"[STAKE] Starting staking for service {self.service.service_id}")
+        logger.info(f"[STAKE] Contract: {staking_contract.address}")
+        logger.info("=" * 50)
+
         # 1. Validation
+        logger.info("[STAKE] Step 1: Checking requirements...")
         requirements = self._check_stake_requirements(staking_contract)
         if not requirements:
+            logger.error("[STAKE] Step 1 FAILED: Requirements not met")
             return False
+        logger.info("[STAKE] Step 1 OK: All requirements met")
 
         min_deposit = requirements["min_deposit"]
+        logger.info(
+            f"[STAKE] Min deposit required: {min_deposit} wei ({min_deposit / 1e18:.2f} OLAS)"
+        )
 
-        # 2. Approve Tokens
-        if not self._approve_staking_tokens(staking_contract, min_deposit):
+        # 2. Approve Service NFT
+        logger.info("[STAKE] Step 2: Approving service NFT...")
+        if not self._approve_staking_tokens(staking_contract):
+            logger.error("[STAKE] Step 2 FAILED: NFT approval failed")
             return False
+        logger.info("[STAKE] Step 2 OK: Service NFT approved")
 
         # 3. Execute Stake Transaction
-        return self._execute_stake_transaction(staking_contract)
+        logger.info("[STAKE] Step 3: Executing stake transaction...")
+        result = self._execute_stake_transaction(staking_contract)
+        if result:
+            logger.info("[STAKE] Step 3 OK: Staking successful")
+            logger.info("=" * 50)
+            logger.info(f"[STAKE] COMPLETE - Service {self.service.service_id} is now staked")
+            logger.info("=" * 50)
+        else:
+            logger.error("[STAKE] Step 3 FAILED: Stake transaction failed")
+        return result
 
     def _check_stake_requirements(self, staking_contract) -> Optional[dict]:
-        """Validate all conditions required for staking."""
+        """Validate all conditions required for staking.
+
+        Checks performed:
+            1. Service State: Must be DEPLOYED (multisig created)
+            2. Token Match: Service token == Staking contract's staking_token
+            3. Agent Bond: Logged (may show 1 wei on-chain, this is normal)
+            4. Available Slots: Contract must have free slots
+
+        Note on OLAS Balance:
+            We do NOT check owner's OLAS balance here. By this point:
+            - 5k OLAS was transferred during activation (to Token Utility)
+            - 5k OLAS was transferred during registration (to Token Utility)
+            - Owner's OLAS balance is 0, and that's correct!
+
+        Args:
+            staking_contract: StakingContract to validate against.
+
+        Returns:
+            Dict with {min_deposit, staking_token} if valid, None otherwise.
+
+        """
         from iwa.plugins.olas.contracts.service import ServiceState
 
-        # Check centralized staking requirements
+        logger.debug("[STAKE] Fetching contract requirements...")
         reqs = staking_contract.get_requirements()
         min_deposit = reqs["min_staking_deposit"]
         required_bond = reqs["required_agent_bond"]
         staking_token = Web3.to_checksum_address(reqs["staking_token"])
         staking_token_lower = staking_token.lower()
 
-        logger.info(f"Checking stake requirements for service {self.service.service_id}")
+        logger.info("[STAKE] Contract requirements:")
+        logger.info(f"[STAKE]   - min_staking_deposit: {min_deposit} wei")
+        logger.info(f"[STAKE]   - required_agent_bond: {required_bond} wei")
+        logger.info(f"[STAKE]   - staking_token: {staking_token}")
 
         # Check service state
+        logger.debug("[STAKE] Checking service state...")
         service_info = self.registry.get_service(self.service.service_id)
         service_state = service_info["state"]
-        logger.info(f"Service state: {service_state.name}")
+        logger.info(f"[STAKE] Service state: {service_state.name}")
 
         if service_state != ServiceState.DEPLOYED:
-            logger.error("Service is not deployed, cannot stake")
+            logger.error(f"[STAKE] FAIL: Service is {service_state.name}, expected DEPLOYED")
             return None
+        logger.debug("[STAKE] OK: Service is DEPLOYED")
 
         # Check token compatibility
         service_token = (self.service.token_address or "").lower()
+        logger.debug(f"[STAKE] Service token: {service_token}")
         if service_token != staking_token_lower:
             logger.error(
-                f"Token mismatch: service was created with {service_token or 'native'}, "
-                f"but staking contract requires {staking_token_lower}"
+                f"[STAKE] FAIL: Token mismatch - service={service_token or 'native'}, "
+                f"contract requires={staking_token_lower}"
             )
             return None
+        logger.debug("[STAKE] OK: Token matches")
 
         # Check agent bond
+        # NOTE: On-chain bond values often show 1 wei regardless of what was passed
+        # during service creation. This is a known issue with the OLAS contracts.
+        # We log a warning but don't block staking because of this discrepancy.
+        logger.debug("[STAKE] Checking agent bond...")
         try:
             agent_ids = service_info["agent_ids"]
             if not agent_ids:
-                logger.error("No agent IDs found for service")
+                logger.error("[STAKE] FAIL: No agent IDs found")
                 return None
 
-            agent_id = agent_ids[0]
-            agent_params = self.registry.get_agent_params(self.service.service_id, agent_id)
+            params_list = self.registry.get_agent_params(self.service.service_id)
+            agent_params = params_list[0]
             current_bond = agent_params["bond"]
+            logger.info(
+                f"[STAKE] Agent bond on-chain: {current_bond} wei (required: {required_bond} wei)"
+            )
 
             if current_bond < required_bond:
-                logger.error(
-                    f"Service agent bond is too low ({current_bond} < {required_bond}). "
-                    "Service must be created with the correct bond amount to be stakeable."
+                logger.warning(
+                    f"[STAKE] WARN: On-chain bond ({current_bond}) < required ({required_bond}). "
+                    "This is a known on-chain reporting issue. Proceeding anyway."
                 )
-                return None
+            else:
+                logger.debug("[STAKE] OK: Agent bond sufficient")
         except Exception as e:
-            logger.warning(f"Could not verify agent bond: {e}")
+            logger.warning(f"[STAKE] WARN: Could not verify agent bond: {e}")
 
         # Check free slots
+        logger.debug("[STAKE] Checking available slots...")
         staked_count = len(staking_contract.get_service_ids())
         max_services = staking_contract.max_num_services
+        free_slots = max_services - staked_count
+        logger.info(f"[STAKE] Slots: {staked_count}/{max_services} used, {free_slots} free")
+
         if staked_count >= max_services:
-            logger.error("Staking contract is full, no free slots available")
+            logger.error("[STAKE] FAIL: No free slots")
             return None
+        logger.debug("[STAKE] OK: Slots available")
 
-        # Check OLAS balance
-        erc20_contract = ERC20Contract(staking_token)
-        master_balance = erc20_contract.balance_of_wei(self.wallet.master_account.address)
-        if master_balance < min_deposit:
-            logger.error(
-                f"Not enough tokens to stake service (have {master_balance}, need {min_deposit})"
-            )
-            return None
+        # NOTE: We don't check OLAS balance here because OLAS was already
+        # deposited to the Token Utility during activation (min_staking_deposit)
+        # and registration (agent_bond). The staking contract pulls from there.
+        logger.debug("[STAKE] OLAS already deposited to Token Utility during activation/registration")
 
         return {"min_deposit": min_deposit, "staking_token": staking_token}
 
-    def _approve_staking_tokens(self, staking_contract, min_deposit: int) -> bool:
-        """Approve both the service NFT and OLAS tokens for staking."""
-        # Approve service NFT
+    def _approve_staking_tokens(self, staking_contract) -> bool:
+        """Approve the Service NFT for transfer to the staking contract.
+
+        What This Does:
+            Calls approve(stakingContract, serviceId) on the Service Registry L2.
+            This allows the staking contract to transferFrom the NFT.
+
+        What This Does NOT Do:
+            - Does NOT approve OLAS tokens (they're already in Token Utility)
+            - Does NOT transfer any tokens (that happens in _execute_stake_transaction)
+
+        Token/NFT Movement:
+            BEFORE: Owner has NFT, staking contract has no approval
+            AFTER:  Owner has NFT, staking contract is approved to take it
+
+        Who Signs:
+            Master account (must be service owner)
+
+        Returns:
+            True if approval succeeded, False otherwise.
+
+        """
+        # Approve service NFT - this is an ERC-721 approval, not ERC-20
+        logger.debug("[STAKE] Approving service NFT for staking contract...")
         approve_tx = self.registry.prepare_approve_tx(
             from_address=self.wallet.master_account.address,
             spender=staking_contract.address,
@@ -275,44 +421,40 @@ class StakingManagerMixin:
         )
 
         if not success:
-            logger.error("Failed to approve staking contract [Service Registry]")
+            logger.error("[STAKE] FAIL: Service NFT approval failed")
             return False
 
-        logger.info("Service token approved for staking contract")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[STAKE] Service NFT approved: {tx_hash}")
+        return True
 
-        # Approve OLAS tokens
-        # We need to get the token address from the contract requirements again or pass it
-        # Retching for simplicity and safety
-        reqs = staking_contract.get_requirements()
-        staking_token = Web3.to_checksum_address(reqs["staking_token"])
-        erc20_contract = ERC20Contract(staking_token)
+    def _execute_stake_transaction(self, staking_contract) -> bool:
+        """Execute the actual stake transaction on the staking contract.
 
-        olas_approve_tx = erc20_contract.prepare_approve_tx(
-            from_address=self.wallet.master_account.address,
-            spender=staking_contract.address,
-            amount_wei=min_deposit,
-        )
+        What Happens Internally:
+            1. Staking contract calls transferFrom to take the Service NFT
+            2. Staking contract reads bond/deposit from Token Utility
+            3. Staking contract records the service as staked
+            4. ServiceStaked event is emitted
 
-        success, receipt = self.wallet.sign_and_send_transaction(
-            transaction=olas_approve_tx,
-            signer_address_or_tag=self.wallet.master_account.address,
-            chain_name=self.chain_name,
-            tags=["olas_approve_olas_token"],
-        )
+        Token Movement:
+            - Service NFT: Owner → Staking Contract (via transferFrom)
+            - OLAS tokens: None! Already in Token Utility
 
-        if not success:
-            logger.error("Failed to approve OLAS tokens for staking contract")
-            return False
+        Why No OLAS Transfer?
+            The staking contract calls ServiceRegistryTokenUtility.getOperatorBalance()
+            to verify the deposited amounts. It doesn't need a new transfer.
 
-        logger.info("OLAS tokens approved for staking contract")
-        return True
+        Returns:
+            True if stake succeeded and ServiceStaked event was found.
 
-    def _execute_stake_transaction(self, staking_contract) -> bool:
-        """Send the stake transaction and verify the result."""
+        """
+        logger.debug("[STAKE] Preparing stake transaction...")
         stake_tx = staking_contract.prepare_stake_tx(
             from_address=self.wallet.master_account.address,
             service_id=self.service.service_id,
         )
+        logger.debug(f"[STAKE] TX prepared: to={stake_tx.get('to')}")
 
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=stake_tx,
@@ -323,33 +465,38 @@ class StakingManagerMixin:
 
         if not success:
             if receipt and "status" in receipt and receipt["status"] == 0:
-                logger.error(f"Stake transaction reverted. Receipt: {receipt}")
-            logger.error("Failed to stake service")
+                logger.error(f"[STAKE] TX reverted. Receipt: {receipt}")
+            logger.error("[STAKE] Stake transaction failed")
             return False
 
-        logger.info("Service stake transaction sent successfully")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[STAKE] TX sent: {tx_hash}")
 
         events = staking_contract.extract_events(receipt)
         event_names = [event["name"] for event in events]
+        logger.debug(f"[STAKE] Events: {event_names}")
 
         if "ServiceStaked" not in event_names:
-            logger.error("Stake service event not found")
+            logger.error("[STAKE] ServiceStaked event not found")
             return False
+        logger.debug("[STAKE] ServiceStaked event confirmed")
 
         # Verify state
         staking_state = staking_contract.get_staking_state(self.service.service_id)
+        logger.debug(f"[STAKE] Final staking state: {staking_state.name}")
+
         if staking_state != StakingState.STAKED:
-            logger.error("Service is not staked after transaction")
+            logger.error(f"[STAKE] FAIL: Service not staked (state={staking_state.name})")
             return False
 
         # Update local state
         self.service.staking_contract_address = EthereumAddress(staking_contract.address)
         self._update_and_save_service_state()
 
-        logger.info("Service staked successfully")
+        logger.info(f"[STAKE] Service {self.service.service_id} is now STAKED")
         return True
 
-    def unstake(self, staking_contract) -> bool:
+    def unstake(self, staking_contract) -> bool:  # noqa: C901
         """Unstake the service from the staking contract."""
         if not self.service:
             logger.error("No active service")
@@ -410,13 +557,13 @@ class StakingManagerMixin:
             chain_name=self.chain_name,
             tags=["olas_unstake_service"],
         )
-
         if not success:
             logger.error(f"Failed to unstake service {self.service.service_id}: Transaction failed")
             return False
 
+        tx_hash = get_tx_hash(receipt)
         logger.info(
-            f"Unstake transaction sent: {receipt.get('transactionHash', '').hex() if receipt else 'No Receipt'}"
+            f"Unstake transaction sent: {tx_hash if receipt else 'No Receipt'}"
         )
 
         events = staking_contract.extract_events(receipt)

iwa/plugins/olas/tests/test_olas_contracts.py

@@ -118,6 +118,8 @@ def test_service_manager_complex_registration(mock_erc20_cls, mock_wallet):
         manager.wallet.transfer_service.approve_erc20.return_value = True
         manager.registry.extract_events.return_value = [{"name": "RegisterInstance"}]
         mock_erc20_cls.return_value.balance_of_wei.return_value = 1000
+        # Fix: Mock allowance to return an int, not MagicMock
+        manager.wallet.transfer_service.get_erc20_allowance.return_value = 0
         assert manager.register_agent(VALID_ADDR, 100) is True
 
     # deploy successes
@@ -160,10 +162,12 @@ def test_service_manager_config_edges(mock_wallet):
     """Test ServiceManager configuration and initialization edge cases."""
     with patch("iwa.plugins.olas.service_manager.Config") as mock_cfg_cls:
         mock_cfg = mock_cfg_cls.return_value
-        mock_cfg.plugins = {"olas": MagicMock()}
-        mock_cfg.plugins["olas"].get_service.return_value = Service(
+        olas_mock = MagicMock()
+        olas_mock.get_service.return_value = Service(
             service_name="t", chain_name="gnosis", service_id=1, agent_ids=[1]
         )
+        # Ensure plugins.get("olas") returns our mock
+        mock_cfg.plugins = {"olas": olas_mock}
         with patch("iwa.plugins.olas.service_manager.ChainInterfaces"):
             # hits 56
             with patch(

iwa/plugins/olas/tests/test_plugin.py

@@ -48,7 +48,12 @@ class TestOlasPlugin:
 
         mock_wallet_class.assert_called_once()
         mock_sm_class.assert_called_once_with(mock_wallet)
-        mock_manager.create.assert_called_once_with("gnosis", "0x1234", "OLAS", 100)
+        mock_manager.create.assert_called_once_with(
+            chain_name="gnosis",
+            service_owner_address_or_tag="0x1234",
+            token_address_or_tag="OLAS",
+            bond_amount_wei=100,
+        )
 
     @patch("iwa.plugins.olas.plugin.Wallet")
     @patch("iwa.plugins.olas.plugin.ServiceManager")

iwa/plugins/olas/tests/test_plugin_full.py

@@ -1,6 +1,6 @@
 """Integration tests for OlasPlugin."""
 
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 import typer
@@ -103,15 +103,18 @@ def test_import_services_cli_full(plugin, runner):
 def test_get_safe_signers_edge_cases(plugin):
     """Test _get_safe_signers with various failure scenarios."""
     # 1. No RPC configured
-    with patch("iwa.core.secrets.secrets") as mock_settings:
-        mock_settings.gnosis_rpc = None
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
+        mock_ci = mock_ci_cls.return_value
+        mock_ci.get.return_value.chain.rpcs = []
         signers, exists = plugin._get_safe_signers("0x1", "gnosis")
         assert signers is None
         assert exists is None
 
     # 2. Safe doesn't exist (raises exception)
-    with patch("iwa.core.secrets.secrets") as mock_settings:
-        mock_settings.gnosis_rpc = MagicMock()
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
+        mock_ci = mock_ci_cls.return_value
+        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
+        mock_ci.get.return_value.chain.rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.side_effect = Exception("Generic error")
@@ -121,8 +124,10 @@ def test_get_safe_signers_edge_cases(plugin):
             assert exists is False
 
     # 3. Success path
-    with patch("iwa.core.secrets.secrets") as mock_settings:
-        mock_settings.gnosis_rpc = MagicMock()
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
+        mock_ci = mock_ci_cls.return_value
+        mock_ci.get.return_value.chain.rpcs = ["http://rpc"]
+        mock_ci.get.return_value.chain.rpc = "http://rpc"
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
             mock_safe.retrieve_owners.return_value = ["0xAgent"]

iwa/plugins/olas/tests/test_service_lifecycle.py

@@ -95,10 +95,7 @@ def test_sm_stake_fail(sm):
     sm.transfer_service.approve_erc20.return_value = True
     sm.wallet.sign_and_send_transaction.return_value = (False, None)
 
-    with (
-        patch("iwa.plugins.olas.contracts.staking.StakingContract") as mock_stk_cls,
-        patch("iwa.plugins.olas.service_manager.staking.ERC20Contract"),
-    ):
+    with patch("iwa.plugins.olas.contracts.staking.StakingContract") as mock_stk_cls:
         mock_stk = mock_stk_cls.return_value
         mock_stk.get_service_info.return_value = {"staking_state": 1}
         mock_stk.staking_token_address = addr