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

iwa/plugins/olas/service_manager/lifecycle.py

@@ -1,4 +1,61 @@
-"""Lifecycle manager mixin."""
+"""Lifecycle manager mixin for OLAS service lifecycle operations.
+
+OLAS Service Lifecycle & Token Flow
+====================================
+
+This module handles the first 4 steps of the service lifecycle (staking is in staking.py).
+Each step involves specific token movements as detailed below.
+
+STEP 1: CREATE SERVICE
+    - What happens:
+        * Service is registered on-chain with metadata (config hash, agent IDs)
+        * Service ownership NFT (ERC-721) is minted to service owner
+        * Bond parameters are recorded but NO tokens move yet
+    - Token Movement: None
+    - Approval: Service Owner → Token Utility (for 2 × bond_amount OLAS)
+    - Next State: PRE_REGISTRATION
+
+STEP 2: ACTIVATE REGISTRATION
+    - What happens:
+        * Service Owner signals readiness to accept agent registrations
+        * Token Utility pulls min_staking_deposit OLAS from owner via transferFrom()
+    - Token Movement:
+        * 5,000 OLAS: Service Owner → Token Utility (for 10k contract)
+    - Native value sent: 1 wei (not 5k OLAS!)
+        * This is MIN_AGENT_BOND, a placeholder for native-bonded services
+        * For OLAS-bonded services, tokens move via Token Utility, not via msg.value
+    - Next State: ACTIVE_REGISTRATION
+
+STEP 3: REGISTER AGENT
+    - What happens:
+        * Agent instance address is registered to the service
+        * Token Utility pulls agent_bond OLAS from owner via transferFrom()
+    - Token Movement:
+        * 5,000 OLAS: Service Owner → Token Utility (for 10k contract)
+    - Native value sent: 1 wei per agent
+        * Same logic as activation - tokens move via Token Utility
+    - Next State: FINISHED_REGISTRATION
+
+STEP 4: DEPLOY
+    - What happens:
+        * Safe multisig is created with agent instances as owners
+        * Service transitions to operational state
+    - Token Movement: None
+    - Next State: DEPLOYED
+
+After DEPLOYED, see staking.py for STEP 5: STAKE
+
+Token Utility Contract:
+    The Token Utility (0xa45E64d13A30a51b91ae0eb182e88a40e9b18eD8 on Gnosis) is the
+    intermediary that holds OLAS deposits. When you call activateRegistration() or
+    registerAgents() on the Service Manager, it internally calls Token Utility's
+    transferFrom() to move OLAS from the service owner.
+
+    This is why:
+    1. We approve Token Utility BEFORE activation/registration
+    2. We send 1 wei native value (not the OLAS amount) in TX
+    3. The actual OLAS moves via transferFrom(), not msg.value
+"""
 
 from typing import List, Optional, Union
 
@@ -9,6 +66,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,
@@ -19,7 +77,26 @@ from iwa.plugins.olas.models import Service
 
 
 class LifecycleManagerMixin:
-    """Mixin for service lifecycle operations."""
+    """Mixin for OLAS service lifecycle operations.
+
+    Handles the CREATE → ACTIVATE → REGISTER → DEPLOY flow for OLAS services.
+    Each method transitions the service to the next state.
+
+    Token Movement Summary:
+        ┌───────────────┬────────────────────────────────────────────────────┐
+        │ Step          │ OLAS Movement                                      │
+        ├───────────────┼────────────────────────────────────────────────────┤
+        │ create()      │ None (just approval to Token Utility)              │
+        │ activate()    │ 5k OLAS → Token Utility (via transferFrom)         │
+        │ register()    │ 5k OLAS → Token Utility (via transferFrom)         │
+        │ deploy()      │ None (just creates Safe multisig)                  │
+        └───────────────┴────────────────────────────────────────────────────┘
+
+    Usage:
+        manager = ServiceManager(wallet)
+        service_id = manager.create(chain_name="gnosis", token_address_or_tag="OLAS")
+        manager.spin_up(bond_amount_wei=5000e18, staking_contract=staking)
+    """
 
     def create(
         self,
@@ -191,7 +268,22 @@ class LifecycleManagerMixin:
         service_owner_account,
         bond_amount_wei: Wei,
     ) -> None:
-        """Approve token utility if a token address is provided."""
+        """Approve Token Utility to spend OLAS tokens (called during create).
+
+        Why 2× bond amount?
+            - Activation requires min_staking_deposit (= bond_amount)
+            - Registration requires agent_bond (= bond_amount)
+            - Total = 2 × bond_amount
+
+        Token Movement: None (this is just an approval, not a transfer)
+
+        Args:
+            token_address: OLAS token address (or None for native).
+            chain_name: Chain to operate on.
+            service_owner_account: Account that owns the OLAS tokens.
+            bond_amount_wei: Bond amount per agent in wei.
+
+        """
         if not token_address:
             return
 
@@ -203,7 +295,7 @@ class LifecycleManagerMixin:
             logger.error(f"OLAS Service Registry Token Utility not found for chain: {chain_name}")
             return
 
-        # Approve the token utility to move tokens (2 * bond amount as per Triton reference)
+        # Approve the token utility to move tokens (2 * bond amount: activation + registration)
         logger.info(f"Approving Token Utility {utility_address} for {2 * bond_amount_wei} tokens")
         approve_success = self.transfer_service.approve_erc20(
             owner_address_or_tag=service_owner_account.address,
@@ -217,28 +309,59 @@ class LifecycleManagerMixin:
             logger.error("Failed to approve Token Utility")
 
     def activate_registration(self) -> bool:
-        """Activate registration for the service."""
+        """Activate registration for the service (Step 2 of lifecycle).
+
+        What This Does:
+            Transitions service from PRE_REGISTRATION → ACTIVE_REGISTRATION.
+            Signals that the service owner is ready to accept agent registrations.
+
+        Token Movement:
+            5,000 OLAS (for 10k contract): Service Owner → Token Utility
+            - Moved internally by Token Utility via transferFrom()
+            - NOT sent as msg.value (that's just 1 wei)
+
+        Native Value Sent:
+            1 wei (MIN_AGENT_BOND placeholder, not the actual deposit)
+
+        Prerequisites:
+            - Service must be in PRE_REGISTRATION state
+            - Token Utility must be approved to spend owner's OLAS
+
+        Returns:
+            True if activation succeeded, False otherwise.
+
+        """
         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:
@@ -255,29 +378,50 @@ class LifecycleManagerMixin:
     def _ensure_token_approval_for_activation(
         self, token_address: str, security_deposit: Wei
     ) -> bool:
-        """Ensure token approval for activation if not native token."""
+        """Ensure token approval for activation if not native token.
+
+        For token-bonded services (e.g., OLAS), we need to approve the
+        ServiceRegistryTokenUtility contract to spend the security deposit
+        (agent bond) on our behalf.
+
+        IMPORTANT: We query the exact bond amount from the Token Utility contract
+        rather than approving a fixed amount, to match the official OLAS middleware.
+        """
         is_native = str(token_address).lower() == str(ZERO_ADDRESS).lower()
         if is_native:
             return True
 
         try:
-            # Check Master Balance first
+            # Get the exact agent bond from Token Utility contract
+            bond_amount = self._get_agent_bond_from_token_utility()
+            if bond_amount is None or bond_amount == 0:
+                logger.warning(
+                    "[ACTIVATE] Could not get agent bond from Token Utility, using security_deposit"
+                )
+                bond_amount = security_deposit
+
+            logger.info(f"[ACTIVATE] Agent bond from Token Utility: {bond_amount} wei")
+
+            # Check owner balance
             balance = self.wallet.balance_service.get_erc20_balance_wei(
                 account_address_or_tag=self.service.service_owner_address,
                 token_address_or_name=token_address,
                 chain_name=self.chain_name,
             )
 
-            if balance < security_deposit:
+            if balance < bond_amount:
                 logger.error(
-                    f"[ACTIVATE] FAIL: Owner balance {balance} < required {security_deposit}"
+                    f"[ACTIVATE] FAIL: Owner balance {balance} < required {bond_amount}"
                 )
+                return False
 
             protocol_contracts = OLAS_CONTRACTS.get(self.chain_name.lower(), {})
             utility_address = protocol_contracts.get("OLAS_SERVICE_REGISTRY_TOKEN_UTILITY")
 
             if utility_address:
-                required_approval = Web3.to_wei(1000, "ether")  # Approve generous amount to be safe
+                # Approve exactly the bond amount (not 1000 OLAS fixed!)
+                # This matches the official OLAS middleware behavior
+                required_approval = bond_amount
 
                 # Check current allowance
                 allowance = self.wallet.transfer_service.get_erc20_allowance(
@@ -287,9 +431,10 @@ class LifecycleManagerMixin:
                     chain_name=self.chain_name,
                 )
 
-                if allowance < Web3.to_wei(10, "ether"):  # Min threshold check
+                if allowance < required_approval:
                     logger.info(
-                        f"Low allowance ({allowance}). Approving Token Utility {utility_address}"
+                        f"[ACTIVATE] Allowance ({allowance}) < required ({required_approval}). "
+                        f"Approving Token Utility {utility_address}"
                     )
                     success_approve = self.wallet.transfer_service.approve_erc20(
                         owner_address_or_tag=self.service.service_owner_address,
@@ -299,33 +444,90 @@ class LifecycleManagerMixin:
                         chain_name=self.chain_name,
                     )
                     if not success_approve:
-                        logger.warning("Token approval transaction returned failure.")
+                        logger.error("[ACTIVATE] Token approval failed")
                         return False
+                    logger.info(f"[ACTIVATE] Approved {required_approval} wei to Token Utility")
+                else:
+                    logger.debug(
+                        f"[ACTIVATE] Sufficient allowance ({allowance} >= {required_approval})"
+                    )
             return True
         except Exception as e:
-            logger.warning(f"Failed to check/approve tokens: {e}")
-            return False  # Return False only if we are strict, or True if we want to try anyway?
-            # Original code swallowed exception but continued.
-            # If we want to return early, we should return False.
-            # However, if we swallow, we return True. Let's stick to original behavior,
-            # BUT original code didn't return False here, it just logged and continued.
-            # To be safer with clean code, if token approval fails, we should probably stop.
-            # Let's assume we return True to match original "swallow" behavior but log it.
-            return True
+            logger.error(f"[ACTIVATE] Failed to check/approve tokens: {e}")
+            return False
+
+    def _get_agent_bond_from_token_utility(self) -> Optional[int]:
+        """Get the agent bond from the ServiceRegistryTokenUtility contract.
+
+        This queries the on-chain Token Utility contract to get the exact bond
+        amount required for the service, matching the official OLAS middleware.
+
+        Returns:
+            The agent bond in wei, or None if the query fails.
+
+        """
+        from iwa.plugins.olas.contracts.service import ServiceRegistryTokenUtilityContract
+
+        try:
+            protocol_contracts = OLAS_CONTRACTS.get(self.chain_name.lower(), {})
+            utility_address = protocol_contracts.get("OLAS_SERVICE_REGISTRY_TOKEN_UTILITY")
+
+            if not utility_address:
+                logger.warning("[ACTIVATE] Token Utility address not found for chain")
+                return None
+
+            # Get agent ID (first agent in the service)
+            service_info = self.registry.get_service(self.service.service_id)
+            agent_ids = service_info.get("agent_ids", [])
+            if not agent_ids:
+                logger.warning("[ACTIVATE] No agent IDs found for service")
+                return None
+            agent_id = agent_ids[0]
+
+            # Use the ServiceRegistryTokenUtilityContract with official ABI
+            token_utility = ServiceRegistryTokenUtilityContract(
+                address=str(utility_address),
+                chain_name=self.chain_name,
+            )
+
+            bond = token_utility.get_agent_bond(self.service.service_id, agent_id)
+
+            logger.debug(
+                f"[ACTIVATE] Token Utility getAgentBond({self.service.service_id}, {agent_id}) = {bond}"
+            )
+            return bond
+
+        except Exception as e:
+            logger.warning(f"[ACTIVATE] Failed to get agent bond from Token Utility: {e}")
+            return None
 
     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.
+        """Send the activation transaction.
+
+        For token-bonded services (e.g., OLAS), we pass MIN_AGENT_BOND (1 wei) as native value.
+        The Token Utility handles OLAS transfers internally based on the service configuration.
+        For native currency services, we pass the full security_deposit.
+        """
+        # Determine if this is a token-bonded service
+        token_address = self._get_service_token(service_id)
+        is_native = str(token_address).lower() == str(ZERO_ADDRESS).lower()
+
+        # For token services, use MIN_AGENT_BOND (1 wei) as native value
+        # The OLAS token approval was done in _ensure_token_approval_for_activation
+        activation_value = security_deposit if is_native else 1
+        logger.info(
+            f"[ACTIVATE] Token={token_address}, is_native={is_native}, "
+            f"activation_value={activation_value} wei"
+        )
+
+        logger.debug(f"[ACTIVATE] Preparing tx: service_id={service_id}, value={activation_value}")
         activate_tx = self.manager.prepare_activate_registration_tx(
             from_address=self.wallet.master_account.address,
             service_id=service_id,
-            value=security_deposit,
+            value=activation_value,
         )
+        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 +535,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 +566,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]:
@@ -418,7 +635,12 @@ class LifecycleManagerMixin:
     def _ensure_agent_token_approval(
         self, agent_account_address: str, bond_amount_wei: Optional[Wei]
     ) -> bool:
-        """Ensure token approval for agent registration if needed."""
+        """Ensure token approval for agent registration if needed.
+
+        For token-bonded services, the service owner must approve the Token Utility
+        contract to transfer the agent bond. We query the exact bond from the
+        Token Utility contract to match the official OLAS middleware.
+        """
         service_id = self.service.service_id
         token_address = self._get_service_token(service_id)
         is_native = str(token_address) == str(ZERO_ADDRESS)
@@ -426,45 +648,90 @@ class LifecycleManagerMixin:
         if is_native:
             return True
 
+        # Get exact bond from Token Utility if not explicitly provided
         if not bond_amount_wei:
-            logger.warning("No bond amount provided for token bonding. Agent might fail to bond.")
-            # We don't return False here, similar to original logic, just warn.
-            # But approval will fail if we try to approve None.
-            return True
+            bond_amount_wei = self._get_agent_bond_from_token_utility()
+            if not bond_amount_wei:
+                logger.warning(
+                    "[REGISTER] Could not get bond from Token Utility, skipping approval"
+                )
+                return True
 
-        # 1. Service Owner Approves Token Utility (for Bond)
-        # The service owner (operator) pays the bond, not the agent.
-        logger.info(f"Service Owner approving Token Utility for bond: {bond_amount_wei} wei")
+        logger.info(f"[REGISTER] Service Owner approving Token Utility for bond: {bond_amount_wei} wei")
 
         utility_address = str(
             OLAS_CONTRACTS[self.chain_name]["OLAS_SERVICE_REGISTRY_TOKEN_UTILITY"]
         )
 
+        # Check current allowance first
+        allowance = self.wallet.transfer_service.get_erc20_allowance(
+            owner_address_or_tag=self.service.service_owner_address,
+            spender_address=utility_address,
+            token_address_or_name=token_address,
+            chain_name=self.chain_name,
+        )
+
+        if allowance >= bond_amount_wei:
+            logger.debug(
+                f"[REGISTER] Sufficient allowance ({allowance} >= {bond_amount_wei})"
+            )
+            return True
+
+        # Use service owner which holds the OLAS tokens (not necessarily master)
         approve_success = self.wallet.transfer_service.approve_erc20(
             token_address_or_name=token_address,
             spender_address_or_tag=utility_address,
             amount_wei=bond_amount_wei,
-            owner_address_or_tag=agent_account_address,
+            owner_address_or_tag=self.service.service_owner_address,
             chain_name=self.chain_name,
         )
         if not approve_success:
-            logger.error("Failed to approve token for agent registration")
+            logger.error("[REGISTER] Failed to approve token for agent registration")
             return False
+
+        logger.info(f"[REGISTER] Approved {bond_amount_wei} wei to Token Utility")
         return True
 
     def _send_register_agent_transaction(self, agent_account_address: str) -> bool:
-        """Send the register agent transaction."""
+        """Send the register agent transaction.
+
+        For token-bonded services (e.g., OLAS), we pass MIN_AGENT_BOND (1 wei) as native value.
+        The Token Utility handles OLAS transfers internally via transferFrom.
+        For native currency services, we pass the full security_deposit * num_agents.
+        """
         service_id = self.service.service_id
-        service_info = self.registry.get_service(service_id)
-        security_deposit = service_info["security_deposit"]
+        token_address = self._get_service_token(service_id)
+        is_native = str(token_address).lower() == str(ZERO_ADDRESS).lower()
+
+        # For token services, use MIN_AGENT_BOND (1 wei) per agent
+        # For native services, use security_deposit * num_agents
+        if is_native:
+            service_info = self.registry.get_service(service_id)
+            security_deposit = service_info["security_deposit"]
+            total_value = security_deposit * len(self.service.agent_ids)
+        else:
+            # MIN_AGENT_BOND = 1 wei per agent
+            total_value = 1 * len(self.service.agent_ids)
+
+        logger.info(
+            f"[REGISTER] Token={token_address}, is_native={is_native}, "
+            f"total_value={total_value} wei"
+        )
+
+        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 +740,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 +792,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 +837,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 +953,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 +986,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 +1015,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