iwa 0.0.1a6__py3-none-any.whl → 0.0.10__py3-none-any.whl

iwa/plugins/olas/service_manager/lifecycle.py

@@ -9,6 +9,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.types import EthereumAddress
+from iwa.core.utils import get_tx_hash
 from iwa.plugins.olas.constants import (
     OLAS_CONTRACTS,
     TRADER_CONFIG_HASH,
@@ -219,26 +220,36 @@ class LifecycleManagerMixin:
     def activate_registration(self) -> bool:
         """Activate registration for the service."""
         service_id = self.service.service_id
+        logger.info(f"[ACTIVATE] Starting activation for service {service_id}")
+
         if not self._validate_pre_registration_state(service_id):
             return False
 
         token_address = self._get_service_token(service_id)
+        logger.debug(f"[ACTIVATE] Token address: {token_address}")
+
         service_info = self.registry.get_service(service_id)
         security_deposit = service_info["security_deposit"]
+        logger.info(f"[ACTIVATE] Security deposit required: {security_deposit} wei")
 
         if not self._ensure_token_approval_for_activation(token_address, security_deposit):
+            logger.error("[ACTIVATE] Token approval failed")
             return False
 
+        logger.info("[ACTIVATE] Sending activation transaction...")
         return self._send_activation_transaction(service_id, security_deposit)
 
     def _validate_pre_registration_state(self, service_id: int) -> bool:
         """Check if service is in PRE_REGISTRATION state."""
-        # Check that the service is created
         service_info = self.registry.get_service(service_id)
         service_state = service_info["state"]
+        logger.debug(f"[ACTIVATE] Current state: {service_state.name}")
         if service_state != ServiceState.PRE_REGISTRATION:
-            logger.error("Service is not created, cannot activate registration")
+            logger.error(
+                f"[ACTIVATE] Service is in {service_state.name}, expected PRE_REGISTRATION"
+            )
             return False
+        logger.debug("[ACTIVATE] State validated: PRE_REGISTRATION")
         return True
 
     def _get_service_token(self, service_id: int) -> str:
@@ -315,17 +326,14 @@ class LifecycleManagerMixin:
 
     def _send_activation_transaction(self, service_id: int, security_deposit: Wei) -> bool:
         """Send the activation transaction."""
-        # Prepare activation transaction
-        # NOTE: For token-based services, the security deposit is handled by the TokenUtility via transferFrom.
-        # However, the ServiceManager (and Registry) REQUIRES that msg.value == security_deposit
-        # even for token-based services (where security_deposit is typically 1 wei).
-        # This native value (1 wei) acts as a protocol validation or fee and MUST be sent.
-        # The 'value' parameter here corresponds to msg.value in the transaction.
+        logger.debug(f"[ACTIVATE] Preparing tx: service_id={service_id}, value={security_deposit}")
         activate_tx = self.manager.prepare_activate_registration_tx(
             from_address=self.wallet.master_account.address,
             service_id=service_id,
             value=security_deposit,
         )
+        logger.debug(f"[ACTIVATE] TX prepared: to={activate_tx.get('to')}")
+
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=activate_tx,
             signer_address_or_tag=self.wallet.master_account.address,
@@ -333,17 +341,21 @@ class LifecycleManagerMixin:
         )
 
         if not success:
-            logger.error("Failed to activate registration")
+            logger.error("[ACTIVATE] Transaction failed")
             return False
 
-        logger.info("Registration activation transaction sent successfully")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[ACTIVATE] TX sent: {tx_hash}")
 
         events = self.registry.extract_events(receipt)
+        event_names = [e["name"] for e in events]
+        logger.debug(f"[ACTIVATE] Events: {event_names}")
 
-        if "ActivateRegistration" not in [event["name"] for event in events]:
-            logger.error("Activation event not found")
+        if "ActivateRegistration" not in event_names:
+            logger.error("[ACTIVATE] ActivateRegistration event not found")
             return False
 
+        logger.info("[ACTIVATE] Success - service is now ACTIVE_REGISTRATION")
         return True
 
     def register_agent(
@@ -360,24 +372,35 @@ class LifecycleManagerMixin:
             True if registration succeeded, False otherwise.
 
         """
+        logger.info(f"[REGISTER] Starting agent registration for service {self.service.service_id}")
+        logger.debug(f"[REGISTER] agent_address={agent_address}, bond={bond_amount_wei}")
+
         if not self._validate_active_registration_state():
             return False
 
         agent_account_address = self._get_or_create_agent_account(agent_address)
         if not agent_account_address:
+            logger.error("[REGISTER] Failed to get/create agent account")
             return False
+        logger.info(f"[REGISTER] Agent address: {agent_account_address}")
 
         if not self._ensure_agent_token_approval(agent_account_address, bond_amount_wei):
+            logger.error("[REGISTER] Token approval failed")
             return False
 
+        logger.info("[REGISTER] Sending register agent transaction...")
         return self._send_register_agent_transaction(agent_account_address)
 
     def _validate_active_registration_state(self) -> bool:
         """Check that the service is in active registration."""
         service_state = self.registry.get_service(self.service.service_id)["state"]
+        logger.debug(f"[REGISTER] Current state: {service_state.name}")
         if service_state != ServiceState.ACTIVE_REGISTRATION:
-            logger.error("Service is not in active registration, cannot register agent")
+            logger.error(
+                f"[REGISTER] Service is in {service_state.name}, expected ACTIVE_REGISTRATION"
+            )
             return False
+        logger.debug("[REGISTER] State validated: ACTIVE_REGISTRATION")
         return True
 
     def _get_or_create_agent_account(self, agent_address: Optional[str]) -> Optional[str]:
@@ -457,14 +480,22 @@ class LifecycleManagerMixin:
         service_id = self.service.service_id
         service_info = self.registry.get_service(service_id)
         security_deposit = service_info["security_deposit"]
+        total_value = security_deposit * len(self.service.agent_ids)
+
+        logger.debug(
+            f"[REGISTER] Preparing tx: agent={agent_account_address}, "
+            f"agent_ids={self.service.agent_ids}, value={total_value}"
+        )
 
         register_tx = self.manager.prepare_register_agents_tx(
             from_address=self.wallet.master_account.address,
             service_id=service_id,
             agent_instances=[agent_account_address],
             agent_ids=self.service.agent_ids,
-            value=(security_deposit * len(self.service.agent_ids)),
+            value=total_value,
         )
+        logger.debug(f"[REGISTER] TX prepared: to={register_tx.get('to')}")
+
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=register_tx,
             signer_address_or_tag=self.wallet.master_account.address,
@@ -473,33 +504,50 @@ class LifecycleManagerMixin:
         )
 
         if not success:
-            logger.error("Failed to register agent")
+            logger.error("[REGISTER] Transaction failed")
             return False
 
-        logger.info("Agent registration transaction sent successfully")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[REGISTER] TX sent: {tx_hash}")
 
         events = self.registry.extract_events(receipt)
+        event_names = [e["name"] for e in events]
+        logger.debug(f"[REGISTER] Events: {event_names}")
 
-        if "RegisterInstance" not in [event["name"] for event in events]:
-            logger.error("Agent registration event not found")
+        if "RegisterInstance" not in event_names:
+            logger.error("[REGISTER] RegisterInstance event not found")
             return False
 
         self.service.agent_address = EthereumAddress(agent_account_address)
         self._update_and_save_service_state()
+        logger.info("[REGISTER] Success - service is now FINISHED_REGISTRATION")
         return True
 
-    def deploy(self) -> Optional[str]:
+    def deploy(self) -> Optional[str]:  # noqa: C901
         """Deploy the service."""
-        # Check that the service has finished registration
+        logger.info(f"[DEPLOY] Starting deployment for service {self.service.service_id}")
+
         service_state = self.registry.get_service(self.service.service_id)["state"]
+        logger.debug(f"[DEPLOY] Current state: {service_state.name}")
+
         if service_state != ServiceState.FINISHED_REGISTRATION:
-            logger.error("Service registration is not finished, cannot deploy")
+            logger.error(
+                f"[DEPLOY] Service is in {service_state.name}, expected FINISHED_REGISTRATION"
+            )
             return False
 
+        logger.debug(f"[DEPLOY] Preparing deploy tx for owner {self.service.service_owner_address}")
         deploy_tx = self.manager.prepare_deploy_tx(
             from_address=self.service.service_owner_address,
             service_id=self.service.service_id,
         )
+
+        if not deploy_tx:
+            logger.error("[DEPLOY] Failed to prepare deploy transaction")
+            return None
+
+        logger.debug(f"[DEPLOY] TX prepared: to={deploy_tx.get('to')}")
+
         success, receipt = self.wallet.sign_and_send_transaction(
             transaction=deploy_tx,
             signer_address_or_tag=self.service.service_owner_address,
@@ -508,29 +556,31 @@ class LifecycleManagerMixin:
         )
 
         if not success:
-            logger.error("Failed to deploy service")
+            logger.error("[DEPLOY] Transaction failed")
             return None
 
-        logger.info("Service deployment transaction sent successfully")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[DEPLOY] TX sent: {tx_hash}")
 
         events = self.registry.extract_events(receipt)
+        event_names = [e["name"] for e in events]
+        logger.debug(f"[DEPLOY] Events: {event_names}")
 
-        if "DeployService" not in [event["name"] for event in events]:
-            logger.error("Deploy service event not found")
+        if "DeployService" not in event_names:
+            logger.error("[DEPLOY] DeployService event not found")
             return None
 
         multisig_address = None
-
         for event in events:
             if event["name"] == "CreateMultisigWithAgents":
                 multisig_address = event["args"]["multisig"]
-                logger.info(f"Service deployed with multisig address: {multisig_address}")
                 break
 
         if multisig_address is None:
-            logger.error("Multisig address not found in deployment events")
+            logger.error("[DEPLOY] Multisig address not found in events")
             return None
 
+        logger.info(f"[DEPLOY] Multisig created: {multisig_address}")
         self.service.multisig_address = EthereumAddress(multisig_address)
         self._update_and_save_service_state()
 
@@ -551,11 +601,11 @@ class LifecycleManagerMixin:
             )
             self.wallet.key_storage.accounts[multisig_address] = safe_account
             self.wallet.key_storage.save()
-            logger.info(f"Registered multisig {multisig_address} in wallet")
+            logger.debug("[DEPLOY] Registered multisig in wallet")
         except Exception as e:
-            logger.warning(f"Failed to register multisig in wallet: {e}")
+            logger.warning(f"[DEPLOY] Failed to register multisig in wallet: {e}")
 
-        logger.info("Service deployed successfully")
+        logger.info("[DEPLOY] Success - service is now DEPLOYED")
         return multisig_address
 
     def terminate(self) -> bool:
@@ -667,21 +717,31 @@ class LifecycleManagerMixin:
         """
         if not service_id:
             if not self.service:
-                logger.error("No active service and no service_id provided")
+                logger.error("[SPIN-UP] No active service and no service_id provided")
                 return False
             service_id = self.service.service_id
-        logger.info(f"Spinning up service {service_id}")
+
+        logger.info("=" * 50)
+        logger.info(f"[SPIN-UP] Starting spin_up for service {service_id}")
+        logger.info(f"[SPIN-UP] Parameters: agent_address={agent_address}, bond={bond_amount_wei}")
+        logger.info(
+            f"[SPIN-UP] Staking contract: {staking_contract.address if staking_contract else 'None'}"
+        )
+        logger.info("=" * 50)
 
         current_state = self._get_service_state_safe(service_id)
         if not current_state:
             return False
 
-        logger.info(f"Service {service_id} initial state: {current_state.name}")
+        logger.info(f"[SPIN-UP] Initial state: {current_state.name}")
 
+        step = 1
         while current_state != ServiceState.DEPLOYED:
             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):
+                logger.error(f"[SPIN-UP] Step {step} FAILED at state {current_state.name}")
                 return False
 
             # Refresh state
@@ -690,21 +750,25 @@ class LifecycleManagerMixin:
                 return False
 
             if current_state == previous_state:
-                logger.error(f"State stuck at {current_state.name} after action")
+                logger.error(f"[SPIN-UP] State stuck at {current_state.name} after action")
                 return False
 
-        logger.info(f"Service deployed successfully (State: {current_state.name})")
+            logger.info(f"[SPIN-UP] Step {step} OK: {previous_state.name} -> {current_state.name}")
+            step += 1
+
+        logger.info(f"[SPIN-UP] Service {service_id} is now DEPLOYED")
 
         # Stake if requested
         if staking_contract:
-            logger.info("Staking service...")
+            logger.info(f"[SPIN-UP] Step {step}: Staking service...")
             if not self.stake(staking_contract):
-                logger.error("Failed to stake service")
-                # Note: Service is DEPLOYED even if stake fails. Return False or True?
-                # Original logic returned False.
+                logger.error("[SPIN-UP] Staking FAILED")
                 return False
-            logger.info("Service staked successfully")
+            logger.info(f"[SPIN-UP] Step {step} OK: Service staked successfully")
 
+        logger.info("=" * 50)
+        logger.info(f"[SPIN-UP] COMPLETE - Service {service_id} is deployed and ready")
+        logger.info("=" * 50)
         return True
 
     def _process_spin_up_state(
@@ -715,24 +779,21 @@ class LifecycleManagerMixin:
     ) -> bool:
         """Process a single state transition for spin up."""
         if current_state == ServiceState.PRE_REGISTRATION:
-            logger.info("Activating registration...")
+            logger.info("[SPIN-UP] Action: activate_registration()")
             if not self.activate_registration():
-                logger.error("Failed to activate registration")
                 return False
         elif current_state == ServiceState.ACTIVE_REGISTRATION:
-            logger.info("Registering agent...")
+            logger.info("[SPIN-UP] Action: register_agent()")
             if not self.register_agent(
                 agent_address=agent_address, bond_amount_wei=bond_amount_wei
             ):
-                logger.error("Failed to register agent")
                 return False
         elif current_state == ServiceState.FINISHED_REGISTRATION:
-            logger.info("Deploying service...")
+            logger.info("[SPIN-UP] Action: deploy()")
             if not self.deploy():
-                logger.error("Failed to deploy service")
                 return False
         else:
-            logger.error(f"Unknown or invalid state for spin up: {current_state.name}")
+            logger.error(f"[SPIN-UP] Invalid state: {current_state.name}")
             return False
         return True
 

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

@@ -8,6 +8,7 @@ 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
 
@@ -175,92 +176,141 @@ 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
+        logger.info("[STAKE] Step 2: Approving tokens...")
         if not self._approve_staking_tokens(staking_contract, min_deposit):
+            logger.error("[STAKE] Step 2 FAILED: Token approval failed")
             return False
+        logger.info("[STAKE] Step 2 OK: Tokens 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."""
         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
+        logger.debug("[STAKE] Checking master OLAS balance...")
         erc20_contract = ERC20Contract(staking_token)
         master_balance = erc20_contract.balance_of_wei(self.wallet.master_account.address)
+        logger.info(
+            f"[STAKE] Master OLAS balance: {master_balance} wei "
+            f"({master_balance / 1e18:.2f} OLAS, need {min_deposit / 1e18:.2f} OLAS)"
+        )
+
         if master_balance < min_deposit:
-            logger.error(
-                f"Not enough tokens to stake service (have {master_balance}, need {min_deposit})"
-            )
+            logger.error(f"[STAKE] FAIL: Insufficient balance ({master_balance} < {min_deposit})")
             return None
+        logger.debug("[STAKE] OK: Sufficient balance")
 
         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
+        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,14 +325,14 @@ 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}")
 
         # Approve OLAS tokens
-        # We need to get the token address from the contract requirements again or pass it
-        # Retching for simplicity and safety
+        logger.debug(f"[STAKE] Approving OLAS tokens ({min_deposit} wei)...")
         reqs = staking_contract.get_requirements()
         staking_token = Web3.to_checksum_address(reqs["staking_token"])
         erc20_contract = ERC20Contract(staking_token)
@@ -301,18 +351,21 @@ class StakingManagerMixin:
         )
 
         if not success:
-            logger.error("Failed to approve OLAS tokens for staking contract")
+            logger.error("[STAKE] FAIL: OLAS token approval failed")
             return False
 
-        logger.info("OLAS tokens approved for staking contract")
+        tx_hash = get_tx_hash(receipt)
+        logger.info(f"[STAKE] OLAS tokens approved: {tx_hash}")
         return True
 
     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 +376,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 +468,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_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")