htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/staking.py

@@ -0,0 +1,1504 @@
+"""
+Staking extrinsics for HTCLI.
+
+Provides all staking-related transaction operations for the Hypertensor blockchain.
+Reference: mesh-template/mesh/substrate/chain_functions.py:685-911
+"""
+
+from typing import Optional
+
+from substrateinterface import Keypair, SubstrateInterface
+
+from ...models.requests.staking import (
+    DelegateStakeAddRequest,
+    DelegateStakeDonateRequest,
+    DelegateStakeRemoveRequest,
+    DelegateStakeSwapRequest,
+    DelegateStakeTransferRequest,
+    NodeDelegateStakeAddRequest,
+    NodeDelegateStakeDonateRequest,
+    NodeDelegateStakeRemoveRequest,
+    NodeDelegateStakeSwapRequest,
+    NodeDelegateStakeTransferRequest,
+    StakeAddRequest,
+    StakeRemoveRequest,
+    StakeSwapFromNodeToSubnetRequest,
+    StakeSwapFromSubnetToNodeRequest,
+    StakeSwapFromSubnetToValidatorRequest,
+    StakeSwapFromValidatorToSubnetRequest,
+    StakeSwapQueueUpdateRequest,
+    ValidatorDelegateStakeAddRequest,
+    ValidatorDelegateStakeDonateRequest,
+    ValidatorDelegateStakeRemoveRequest,
+    ValidatorDelegateStakeSwapRequest,
+    ValidatorDelegateStakeTransferRequest,
+)
+from ...models.responses.staking import (
+    ClaimUnbondingsResponse,
+    DelegateStakeAddResponse,
+    DelegateStakeDonateResponse,
+    DelegateStakeRemoveResponse,
+    DelegateStakeSwapResponse,
+    DelegateStakeTransferResponse,
+    NodeDelegateStakeAddResponse,
+    NodeDelegateStakeDonateResponse,
+    NodeDelegateStakeRemoveResponse,
+    NodeDelegateStakeSwapResponse,
+    NodeDelegateStakeTransferResponse,
+    StakeAddResponse,
+    StakeRemoveResponse,
+    StakeSwapFromNodeToSubnetResponse,
+    StakeSwapFromSubnetToNodeResponse,
+    StakeSwapFromSubnetToValidatorResponse,
+    StakeSwapFromValidatorToSubnetResponse,
+    StakeSwapQueueUpdateResponse,
+    ValidatorDelegateStakeAddResponse,
+    ValidatorDelegateStakeDonateResponse,
+    ValidatorDelegateStakeRemoveResponse,
+    ValidatorDelegateStakeSwapResponse,
+    ValidatorDelegateStakeTransferResponse,
+)
+from ...utils.logging import get_logger
+from .base import BaseExtrinsicClient, get_user_friendly_error
+
+logger = get_logger(__name__)
+
+
+class StakingExtrinsics(BaseExtrinsicClient):
+    """Client for staking-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the staking client."""
+        super().__init__(substrate)
+
+    # ============================================================================
+    # DIRECT STAKING
+    # ============================================================================
+
+    def add_stake(self, request: StakeAddRequest, keypair: Keypair) -> StakeAddResponse:
+        """
+        Add direct stake to a subnet node.
+
+        Args:
+            request: Stake addition request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            StakeAddResponse with transaction details
+
+        Reference: mesh-template lines 685-731
+        """
+        try:
+            logger.info(
+                f"Adding {request.stake_amount} wei stake to subnet {request.subnet_id} "
+                f"node {request.subnet_node_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="add_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "hotkey": request.hotkey,
+                    "stake_to_be_added": request.stake_amount,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Extract stake added event
+                stake_event = self._extract_event_by_type(
+                    result.get("events", []), "Network", "StakeAdded"
+                )
+
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "hotkey": request.hotkey,
+                    "stake_added": request.stake_amount,
+                    "message": f"Successfully staked {request.stake_amount / 1e18:.4f} TENSOR",
+                }
+
+                # Try to get total stake from event if available
+                if stake_event:
+                    # Event attributes: (coldkey, hotkey, subnet_id, amount)
+                    response_data["stake_added"] = self._extract_attribute_value(
+                        stake_event, 3, request.stake_amount
+                    )
+
+                return StakeAddResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return StakeAddResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to add stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error adding stake: {e}")
+            return StakeAddResponse(
+                success=False, error=str(e), message=f"Error adding stake: {str(e)}"
+            )
+
+    def remove_stake(
+        self, request: StakeRemoveRequest, keypair: Keypair
+    ) -> StakeRemoveResponse:
+        """
+        Remove stake from a subnet node (creates unbonding entry).
+
+        Args:
+            request: Stake removal request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            StakeRemoveResponse with transaction details
+
+        Reference: mesh-template lines 733-777
+        """
+        try:
+            logger.info(
+                f"Removing {request.stake_amount} wei stake from subnet {request.subnet_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "hotkey": request.hotkey,
+                    "stake_to_be_removed": request.stake_amount,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": request.subnet_id,
+                    "stake_removed": request.stake_amount,
+                    "message": f"Successfully removed {request.stake_amount / 1e18:.4f} TENSOR (will unbond in 7 epochs)",
+                }
+
+                return StakeRemoveResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return StakeRemoveResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to remove stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error removing stake: {e}")
+            return StakeRemoveResponse(
+                success=False, error=str(e), message=f"Error removing stake: {str(e)}"
+            )
+
+    def claim_unbondings(self, keypair: Keypair) -> ClaimUnbondingsResponse:
+        """
+        Claim all unbonded stake that has completed the unbonding period.
+
+        Args:
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            ClaimUnbondingsResponse with claim details
+
+        Reference: mesh-template lines 779-805
+        """
+        try:
+            logger.info("Claiming unbonded stake")
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network", call_function="claim_unbondings", call_params={}
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Try to extract amount from event
+                claim_event = self._extract_event_by_type(
+                    result.get("events", []), "Network", "UnbondingsClaimed"
+                )
+
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "message": "Successfully claimed unbonded stake",
+                }
+
+                if claim_event:
+                    total_claimed = self._extract_attribute_value(claim_event, 1, 0)
+                    response_data["total_claimed"] = total_claimed
+                    response_data["message"] = (
+                        f"Claimed {total_claimed / 1e18:.4f} TENSOR"
+                    )
+
+                return ClaimUnbondingsResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return ClaimUnbondingsResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to claim unbondings: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error claiming unbondings: {e}")
+            return ClaimUnbondingsResponse(
+                success=False,
+                error=str(e),
+                message=f"Error claiming unbondings: {str(e)}",
+            )
+
+    # ============================================================================
+    # DELEGATE STAKING (SUBNET LEVEL)
+    # ============================================================================
+
+    def add_to_delegate_stake(
+        self, request: DelegateStakeAddRequest, keypair: Keypair
+    ) -> DelegateStakeAddResponse:
+        """
+        Add delegate stake to a subnet.
+
+        Args:
+            request: Delegate stake addition request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            DelegateStakeAddResponse with share details
+
+        Reference: mesh-template lines 807-849
+        """
+        try:
+            logger.info(
+                f"Adding {request.stake_amount} wei delegate stake to subnet {request.subnet_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="add_to_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "stake_to_be_added": request.stake_amount,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Extract amount from events
+                amount_added = request.stake_amount
+                shares_received = 0
+
+                for event in result.get("events", []):
+                    if hasattr(event, "value"):
+                        event_id = event.value.get("event_id", "")
+                        if event_id == "SubnetDelegateStakeAdded":
+                            attributes = event.value.get("attributes", {})
+                            if isinstance(attributes, dict):
+                                amount_added = attributes.get("amount", amount_added)
+                            elif (
+                                isinstance(attributes, (list, tuple))
+                                and len(attributes) >= 3
+                            ):
+                                # [subnet_id, account_id, amount]
+                                amount_added = attributes[2]
+
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": request.subnet_id,
+                    "stake_added": amount_added,
+                    "shares_received": shares_received,
+                    "message": f"Successfully delegated {amount_added / 1e18:.4f} TENSOR",
+                }
+
+                return DelegateStakeAddResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return DelegateStakeAddResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to add delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error adding delegate stake: {e}")
+            return DelegateStakeAddResponse(
+                success=False,
+                error=str(e),
+                message=f"Error adding delegate stake: {str(e)}",
+            )
+
+    def remove_delegate_stake(
+        self, request: DelegateStakeRemoveRequest, keypair: Keypair
+    ) -> DelegateStakeRemoveResponse:
+        """
+        Remove delegate stake from a subnet.
+
+        Args:
+            request: Delegate stake removal request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            DelegateStakeRemoveResponse with balance details
+        """
+        try:
+            logger.info(
+                f"Removing {request.shares_to_be_removed} shares from subnet {request.subnet_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "shares_to_be_removed": request.shares_to_be_removed,  # Blockchain uses shares
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": request.subnet_id,
+                    "message": f"Successfully removed {request.shares_to_be_removed} shares from delegate stake",
+                }
+
+                return DelegateStakeRemoveResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return DelegateStakeRemoveResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to remove delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error removing delegate stake: {e}")
+            return DelegateStakeRemoveResponse(
+                success=False,
+                error=str(e),
+                message=f"Error removing delegate stake: {str(e)}",
+            )
+
+    def transfer_delegate_stake(
+        self, request: DelegateStakeTransferRequest, keypair: Keypair
+    ) -> DelegateStakeTransferResponse:
+        """
+        Transfer delegate stake between accounts.
+
+        Args:
+            request: Delegate stake transfer request
+            keypair: Keypair for signing
+
+        Returns:
+            DelegateStakeTransferResponse
+        """
+        try:
+            logger.info(
+                f"Transferring {request.delegate_stake_shares_to_transfer} shares delegate stake "
+                f"from {request.from_account} to {request.to_account}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="transfer_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "from": request.from_account,
+                    "to_account_id": request.to_account,
+                    "delegate_stake_shares_to_transfer": request.delegate_stake_shares_to_transfer,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return DelegateStakeTransferResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.subnet_id,
+                    from_account=request.from_account,
+                    to_account=request.to_account,
+                    message="Delegate stake transferred successfully",
+                )
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return DelegateStakeTransferResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to transfer delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error transferring delegate stake: {e}")
+            return DelegateStakeTransferResponse(
+                success=False,
+                error=str(e),
+                message=f"Error transferring delegate stake: {str(e)}",
+            )
+
+    def swap_delegate_stake(
+        self, request: DelegateStakeSwapRequest, keypair: Keypair
+    ) -> DelegateStakeSwapResponse:
+        """
+        Swap delegate stake between subnets.
+
+        Args:
+            request: Delegate stake swap request
+            keypair: Keypair for signing
+
+        Returns:
+            DelegateStakeSwapResponse
+        """
+        try:
+            logger.info(
+                f"Swapping {request.delegate_stake_shares_to_swap} shares delegate stake "
+                f"from subnet {request.from_subnet_id} to {request.to_subnet_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_delegate_stake",
+                call_params={
+                    "from_subnet_id": request.from_subnet_id,
+                    "to_subnet_id": request.to_subnet_id,
+                    "delegate_stake_shares_to_swap": request.delegate_stake_shares_to_swap,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return DelegateStakeSwapResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    from_subnet_id=request.from_subnet_id,
+                    to_subnet_id=request.to_subnet_id,
+                    message="Delegate stake swapped successfully",
+                )
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return DelegateStakeSwapResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to swap delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error swapping delegate stake: {e}")
+            return DelegateStakeSwapResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping delegate stake: {str(e)}",
+            )
+
+    def donate_delegate_stake(
+        self, request: DelegateStakeDonateRequest, keypair: Keypair
+    ) -> DelegateStakeDonateResponse:
+        """
+        Donate delegate stake to subnet treasury.
+
+        Args:
+            request: Delegate stake donation request
+            keypair: Keypair for signing
+
+        Returns:
+            DelegateStakeDonateResponse
+        """
+        try:
+            logger.info(
+                f"Donating {request.stake_amount} wei delegate stake to subnet {request.subnet_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="donate_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "amount": request.stake_amount,
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return DelegateStakeDonateResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.subnet_id,
+                    message=f"Donated {request.stake_amount / 1e18:.4f} TENSOR to subnet treasury",
+                )
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return DelegateStakeDonateResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to donate delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error donating delegate stake: {e}")
+            return DelegateStakeDonateResponse(
+                success=False,
+                error=str(e),
+                message=f"Error donating delegate stake: {str(e)}",
+            )
+
+    # ============================================================================
+    # VALIDATOR DELEGATE STAKING
+    # ============================================================================
+
+    def add_to_validator_delegate_stake(
+        self, request: ValidatorDelegateStakeAddRequest, keypair: Keypair
+    ) -> ValidatorDelegateStakeAddResponse:
+        """Add delegate stake to a validator."""
+        try:
+            logger.info(
+                f"Adding {request.delegate_stake_to_be_added} wei validator delegate stake "
+                f"to validator {request.validator_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="add_validator_delegate_stake",
+                call_params={
+                    "validator_id": request.validator_id,
+                    "delegate_stake_to_be_added": request.delegate_stake_to_be_added,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return ValidatorDelegateStakeAddResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    validator_id=request.validator_id,
+                    stake_added=request.delegate_stake_to_be_added,
+                    shares_received=0,
+                    message=f"Successfully delegated {request.delegate_stake_to_be_added / 1e18:.4f} TENSOR to validator",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return ValidatorDelegateStakeAddResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to add validator delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error adding validator delegate stake: {e}")
+            return ValidatorDelegateStakeAddResponse(
+                success=False,
+                error=str(e),
+                message=f"Error adding validator delegate stake: {str(e)}",
+            )
+
+    def remove_validator_delegate_stake(
+        self, request: ValidatorDelegateStakeRemoveRequest, keypair: Keypair
+    ) -> ValidatorDelegateStakeRemoveResponse:
+        """Remove delegate stake from a validator."""
+        try:
+            logger.info(
+                f"Removing {request.validator_delegate_stake_shares_to_be_removed} "
+                f"validator delegate shares from validator {request.validator_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_validator_delegate_stake",
+                call_params={
+                    "validator_id": request.validator_id,
+                    "validator_delegate_stake_shares_to_be_removed": request.validator_delegate_stake_shares_to_be_removed,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return ValidatorDelegateStakeRemoveResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    validator_id=request.validator_id,
+                    shares_removed=request.validator_delegate_stake_shares_to_be_removed,
+                    message=f"Successfully removed {request.validator_delegate_stake_shares_to_be_removed} shares",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return ValidatorDelegateStakeRemoveResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to remove validator delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error removing validator delegate stake: {e}")
+            return ValidatorDelegateStakeRemoveResponse(
+                success=False,
+                error=str(e),
+                message=f"Error removing validator delegate stake: {str(e)}",
+            )
+
+    def transfer_validator_delegate_stake(
+        self, request: ValidatorDelegateStakeTransferRequest, keypair: Keypair
+    ) -> ValidatorDelegateStakeTransferResponse:
+        """Transfer validator delegate stake shares to another account."""
+        try:
+            logger.info(
+                f"Transferring {request.validator_delegate_stake_shares_to_transfer} "
+                f"validator delegate shares from validator {request.validator_id} "
+                f"to account {request.to_account_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="transfer_validator_delegate_stake",
+                call_params={
+                    "validator_id": request.validator_id,
+                    "to_account_id": request.to_account_id,
+                    "validator_delegate_stake_shares_to_transfer": request.validator_delegate_stake_shares_to_transfer,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return ValidatorDelegateStakeTransferResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    validator_id=request.validator_id,
+                    to_account=request.to_account_id,
+                    shares_transferred=request.validator_delegate_stake_shares_to_transfer,
+                    message="Validator delegate stake transferred successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return ValidatorDelegateStakeTransferResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to transfer validator delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error transferring validator delegate stake: {e}")
+            return ValidatorDelegateStakeTransferResponse(
+                success=False,
+                error=str(e),
+                message=f"Error transferring validator delegate stake: {str(e)}",
+            )
+
+    def swap_validator_delegate_stake(
+        self, request: ValidatorDelegateStakeSwapRequest, keypair: Keypair
+    ) -> ValidatorDelegateStakeSwapResponse:
+        """Swap validator delegate stake shares between validators."""
+        try:
+            logger.info(
+                "Swapping validator delegate shares from validator %s to validator %s",
+                request.from_validator_id,
+                request.to_validator_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_validator_delegate_stake",
+                call_params={
+                    "from_validator_id": request.from_validator_id,
+                    "to_validator_id": request.to_validator_id,
+                    "stake_to_be_removed": request.stake_to_be_removed,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return ValidatorDelegateStakeSwapResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    from_validator_id=request.from_validator_id,
+                    to_validator_id=request.to_validator_id,
+                    shares_swapped=request.stake_to_be_removed,
+                    message="Validator delegate stake swap submitted",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return ValidatorDelegateStakeSwapResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap validator delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping validator delegate stake: {e}")
+            return ValidatorDelegateStakeSwapResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping validator delegate stake: {str(e)}",
+            )
+
+    def donate_validator_delegate_stake(
+        self, request: ValidatorDelegateStakeDonateRequest, keypair: Keypair
+    ) -> ValidatorDelegateStakeDonateResponse:
+        """Donate stake to a validator delegate pool."""
+        try:
+            logger.info(
+                f"Donating {request.amount} wei to validator {request.validator_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="donate_validator_delegate_stake",
+                call_params={
+                    "validator_id": request.validator_id,
+                    "amount": request.amount,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return ValidatorDelegateStakeDonateResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    validator_id=request.validator_id,
+                    balance_donated=request.amount,
+                    message=f"Donated {request.amount / 1e18:.4f} TENSOR to validator delegate pool",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return ValidatorDelegateStakeDonateResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to donate validator delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error donating validator delegate stake: {e}")
+            return ValidatorDelegateStakeDonateResponse(
+                success=False,
+                error=str(e),
+                message=f"Error donating validator delegate stake: {str(e)}",
+            )
+
+    # ============================================================================
+    # NODE DELEGATE STAKING
+    # ============================================================================
+
+    def add_to_node_delegate_stake(
+        self, request: NodeDelegateStakeAddRequest, keypair: Keypair
+    ) -> NodeDelegateStakeAddResponse:
+        """
+        Add delegate stake to a specific node.
+
+        Args:
+            request: Node delegate stake addition request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            NodeDelegateStakeAddResponse with share details
+
+        Reference: mesh-template lines 851-894
+        """
+        try:
+            logger.info(
+                f"Adding {request.node_delegate_stake_to_be_added} wei node delegate stake to "
+                f"subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="add_to_node_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "node_delegate_stake_to_be_added": request.node_delegate_stake_to_be_added,  # Blockchain parameter name
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Extract amount from events
+                amount_added = request.node_delegate_stake_to_be_added
+                shares_received = 0
+
+                for event in result.get("events", []):
+                    if hasattr(event, "value"):
+                        event_id = event.value.get("event_id", "")
+                        if event_id == "DelegateNodeStakeAdded":
+                            attributes = event.value.get("attributes", {})
+                            if isinstance(attributes, dict):
+                                amount_added = attributes.get("amount", amount_added)
+                            elif (
+                                isinstance(attributes, (list, tuple))
+                                and len(attributes) >= 4
+                            ):
+                                # [account_id, subnet_id, subnet_node_id, amount]
+                                amount_added = attributes[3]
+
+                response_data = {
+                    "success": True,
+                    "transaction_hash": result.get("extrinsic_hash"),
+                    "block_hash": result.get("block_hash"),
+                    "block_number": result.get("block_number"),
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "stake_added": amount_added,  # Use stake_added to match model
+                    "shares_received": shares_received,
+                    "message": f"Successfully delegated {amount_added / 1e18:.4f} TENSOR to node",
+                }
+
+                return NodeDelegateStakeAddResponse(**response_data)
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return NodeDelegateStakeAddResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to add node delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error adding node delegate stake: {e}")
+            return NodeDelegateStakeAddResponse(
+                success=False,
+                error=str(e),
+                message=f"Error adding node delegate stake: {str(e)}",
+            )
+
+    def remove_node_delegate_stake(
+        self, request: NodeDelegateStakeRemoveRequest, keypair: Keypair
+    ) -> NodeDelegateStakeRemoveResponse:
+        """
+        Remove delegate stake from a specific node.
+
+        Args:
+            request: Node delegate stake removal request
+            keypair: Keypair for signing (coldkey)
+
+        Returns:
+            NodeDelegateStakeRemoveResponse
+        """
+        try:
+            logger.info(
+                f"Removing {request.node_delegate_stake_shares_to_be_removed} shares from "
+                f"subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            # Compose call
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="remove_node_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "node_delegate_stake_shares_to_be_removed": request.node_delegate_stake_shares_to_be_removed,  # Blockchain parameter
+                },
+            )
+
+            # Submit with retry
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return NodeDelegateStakeRemoveResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.subnet_id,
+                    subnet_node_id=request.subnet_node_id,
+                    shares_removed=request.node_delegate_stake_shares_to_be_removed,
+                    message=f"Successfully removed {request.node_delegate_stake_shares_to_be_removed} shares",
+                )
+            else:
+                error_msg = get_user_friendly_error(
+                    result.get("error", "Unknown error")
+                )
+                return NodeDelegateStakeRemoveResponse(
+                    success=False,
+                    error=error_msg,
+                    message=f"Failed to remove node delegate stake: {error_msg}",
+                )
+
+        except Exception as e:
+            logger.error(f"Error removing node delegate stake: {e}")
+            return NodeDelegateStakeRemoveResponse(
+                success=False,
+                error=str(e),
+                message=f"Error removing node delegate stake: {str(e)}",
+            )
+
+    def transfer_node_delegate_stake(
+        self, request: NodeDelegateStakeTransferRequest, keypair: Keypair
+    ) -> NodeDelegateStakeTransferResponse:
+        """
+        Transfer node delegate stake shares to another account.
+        """
+        try:
+            logger.info(
+                f"Transferring {request.node_delegate_stake_shares_to_transfer} shares "
+                f"from subnet {request.subnet_id} node {request.subnet_node_id} "
+                f"to account {request.to_account_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="transfer_node_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "to_account_id": request.to_account_id,
+                    "node_delegate_stake_shares_to_transfer": request.node_delegate_stake_shares_to_transfer,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return NodeDelegateStakeTransferResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.subnet_id,
+                    subnet_node_id=request.subnet_node_id,
+                    to_account=request.to_account_id,
+                    shares_transferred=request.node_delegate_stake_shares_to_transfer,
+                    message="Node delegate stake transferred successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return NodeDelegateStakeTransferResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to transfer node delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error transferring node delegate stake: {e}")
+            return NodeDelegateStakeTransferResponse(
+                success=False,
+                error=str(e),
+                message=f"Error transferring node delegate stake: {str(e)}",
+            )
+
+    def swap_node_delegate_stake(
+        self, request: NodeDelegateStakeSwapRequest, keypair: Keypair
+    ) -> NodeDelegateStakeSwapResponse:
+        """
+        Swap node delegate stake shares between nodes.
+        """
+        try:
+            logger.info(
+                "Swapping node delegate shares from subnet %s node %s to subnet %s node %s",
+                request.from_subnet_id,
+                request.from_subnet_node_id,
+                request.to_subnet_id,
+                request.to_subnet_node_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_node_delegate_stake",
+                call_params={
+                    "from_subnet_id": request.from_subnet_id,
+                    "from_subnet_node_id": request.from_subnet_node_id,
+                    "to_subnet_id": request.to_subnet_id,
+                    "to_subnet_node_id": request.to_subnet_node_id,
+                    "node_delegate_stake_shares_to_swap": request.node_delegate_stake_shares_to_swap,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return NodeDelegateStakeSwapResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    from_subnet_id=request.from_subnet_id,
+                    from_subnet_node_id=request.from_subnet_node_id,
+                    to_subnet_id=request.to_subnet_id,
+                    to_subnet_node_id=request.to_subnet_node_id,
+                    shares_swapped=request.node_delegate_stake_shares_to_swap,
+                    message="Node delegate stake swap submitted (queued)",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return NodeDelegateStakeSwapResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap node delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping node delegate stake: {e}")
+            return NodeDelegateStakeSwapResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping node delegate stake: {str(e)}",
+            )
+
+    def donate_node_delegate_stake(
+        self, request: NodeDelegateStakeDonateRequest, keypair: Keypair
+    ) -> NodeDelegateStakeDonateResponse:
+        """
+        Donate node delegate stake (in wei) to a node's delegate pool.
+        """
+        try:
+            logger.info(
+                f"Donating {request.amount} wei to subnet {request.subnet_id} node {request.subnet_node_id}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="donate_node_delegate_stake",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "subnet_node_id": request.subnet_node_id,
+                    "amount": request.amount,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return NodeDelegateStakeDonateResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.subnet_id,
+                    subnet_node_id=request.subnet_node_id,
+                    balance_donated=request.amount,
+                    message=f"Donated {request.amount / 1e18:.4f} TENSOR to node delegate pool",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return NodeDelegateStakeDonateResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to donate node delegate stake: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error donating node delegate stake: {e}")
+            return NodeDelegateStakeDonateResponse(
+                success=False,
+                error=str(e),
+                message=f"Error donating node delegate stake: {str(e)}",
+            )
+
+    def swap_from_node_to_subnet(
+        self, request: StakeSwapFromNodeToSubnetRequest, keypair: Keypair
+    ) -> StakeSwapFromNodeToSubnetResponse:
+        """
+        Swap stake from a node delegate position to a subnet delegate position.
+        """
+        try:
+            logger.info(
+                "Swapping node delegate shares (%s) from subnet %s node %s to subnet %s",
+                request.node_delegate_stake_shares_to_swap,
+                request.from_subnet_id,
+                request.from_subnet_node_id,
+                request.to_subnet_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_from_node_to_subnet",
+                call_params={
+                    "from_subnet_id": request.from_subnet_id,
+                    "from_subnet_node_id": request.from_subnet_node_id,
+                    "to_subnet_id": request.to_subnet_id,
+                    "node_delegate_stake_shares_to_swap": request.node_delegate_stake_shares_to_swap,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return StakeSwapFromNodeToSubnetResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.from_subnet_id,
+                    subnet_node_id=request.from_subnet_node_id,
+                    stake_swapped=request.node_delegate_stake_shares_to_swap,
+                    message="Swap from node to subnet queued successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return StakeSwapFromNodeToSubnetResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap from node to subnet: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping node -> subnet delegate stake: {e}")
+            return StakeSwapFromNodeToSubnetResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping node -> subnet delegate stake: {str(e)}",
+            )
+
+    def swap_from_subnet_to_node(
+        self, request: StakeSwapFromSubnetToNodeRequest, keypair: Keypair
+    ) -> StakeSwapFromSubnetToNodeResponse:
+        """
+        Swap stake from a subnet delegate position to a node delegate position.
+        """
+        try:
+            logger.info(
+                "Swapping subnet delegate shares (%s) from subnet %s to subnet %s node %s",
+                request.delegate_stake_shares_to_swap,
+                request.from_subnet_id,
+                request.to_subnet_id,
+                request.to_subnet_node_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_from_subnet_to_node",
+                call_params={
+                    "from_subnet_id": request.from_subnet_id,
+                    "to_subnet_id": request.to_subnet_id,
+                    "to_subnet_node_id": request.to_subnet_node_id,
+                    "node_delegate_stake_shares_to_swap": request.delegate_stake_shares_to_swap,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return StakeSwapFromSubnetToNodeResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.to_subnet_id,
+                    subnet_node_id=request.to_subnet_node_id,
+                    stake_swapped=request.delegate_stake_shares_to_swap,
+                    message="Swap from subnet to node queued successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return StakeSwapFromSubnetToNodeResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap from subnet to node: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping subnet -> node delegate stake: {e}")
+            return StakeSwapFromSubnetToNodeResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping subnet -> node delegate stake: {str(e)}",
+            )
+
+    def swap_from_validator_to_subnet(
+        self, request: StakeSwapFromValidatorToSubnetRequest, keypair: Keypair
+    ) -> StakeSwapFromValidatorToSubnetResponse:
+        """Swap stake from a validator delegate position to a subnet delegate position."""
+        try:
+            logger.info(
+                "Swapping validator delegate shares (%s) from validator %s to subnet %s",
+                request.node_delegate_stake_shares_to_swap,
+                request.from_validator_id,
+                request.to_subnet_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_from_validator_to_subnet",
+                call_params={
+                    "from_validator_id": request.from_validator_id,
+                    "to_subnet_id": request.to_subnet_id,
+                    "node_delegate_stake_shares_to_swap": request.node_delegate_stake_shares_to_swap,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return StakeSwapFromValidatorToSubnetResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    validator_id=request.from_validator_id,
+                    subnet_id=request.to_subnet_id,
+                    stake_swapped=request.node_delegate_stake_shares_to_swap,
+                    validator_shares_removed=request.node_delegate_stake_shares_to_swap,
+                    message="Swap from validator to subnet queued successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return StakeSwapFromValidatorToSubnetResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap from validator to subnet: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping validator -> subnet delegate stake: {e}")
+            return StakeSwapFromValidatorToSubnetResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping validator -> subnet delegate stake: {str(e)}",
+            )
+
+    def swap_from_subnet_to_validator(
+        self, request: StakeSwapFromSubnetToValidatorRequest, keypair: Keypair
+    ) -> StakeSwapFromSubnetToValidatorResponse:
+        """Swap stake from a subnet delegate position to a validator delegate position."""
+        try:
+            logger.info(
+                "Swapping subnet delegate shares (%s) from subnet %s to validator %s",
+                request.subnet_delegate_stake_shares_to_swap,
+                request.from_subnet_id,
+                request.to_validator_id,
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="swap_from_subnet_to_validator",
+                call_params={
+                    "from_subnet_id": request.from_subnet_id,
+                    "to_validator_id": request.to_validator_id,
+                    "subnet_delegate_stake_shares_to_swap": request.subnet_delegate_stake_shares_to_swap,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return StakeSwapFromSubnetToValidatorResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    block_number=result.get("block_number"),
+                    subnet_id=request.from_subnet_id,
+                    validator_id=request.to_validator_id,
+                    stake_swapped=request.subnet_delegate_stake_shares_to_swap,
+                    subnet_shares_removed=request.subnet_delegate_stake_shares_to_swap,
+                    message="Swap from subnet to validator queued successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return StakeSwapFromSubnetToValidatorResponse(
+                success=False,
+                error=error_msg,
+                message=f"Failed to swap from subnet to validator: {error_msg}",
+            )
+
+        except Exception as e:
+            logger.error(f"Error swapping subnet -> validator delegate stake: {e}")
+            return StakeSwapFromSubnetToValidatorResponse(
+                success=False,
+                error=str(e),
+                message=f"Error swapping subnet -> validator delegate stake: {str(e)}",
+            )
+
+    def update_swap_queue(
+        self, request: StakeSwapQueueUpdateRequest, keypair: Keypair
+    ) -> StakeSwapQueueUpdateResponse:
+        """
+        Update a queued swap entry to point to a new target.
+        """
+        try:
+            logger.info(f"Updating swap queue entry {request.queue_id}")
+
+            signer_account = keypair.ss58_address
+            new_call_variant = self._build_swap_queue_call(
+                request.new_call, signer_account
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_swap_queue",
+                call_params={
+                    "id": request.queue_id,
+                    "new_call": new_call_variant,
+                },
+            )
+
+            result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                return StakeSwapQueueUpdateResponse(
+                    success=True,
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_number=result.get("block_number"),
+                    queue_updated=True,
+                    queue_position=request.queue_id,
+                    message="Swap queue entry updated successfully",
+                )
+            error_msg = get_user_friendly_error(result.get("error", "Unknown error"))
+            return StakeSwapQueueUpdateResponse(
+                success=False,
+                error=error_msg,
+                queue_updated=False,
+                queue_position=request.queue_id,
+                message=f"Failed to update swap queue: {error_msg}",
+            )
+
+        except ValueError as ve:
+            logger.error(f"Invalid swap queue payload: {ve}")
+            return StakeSwapQueueUpdateResponse(
+                success=False,
+                error=str(ve),
+                queue_updated=False,
+                queue_position=request.queue_id,
+                message=str(ve),
+            )
+        except Exception as e:
+            logger.error(f"Error updating swap queue: {e}")
+            return StakeSwapQueueUpdateResponse(
+                success=False,
+                error=str(e),
+                queue_updated=False,
+                queue_position=request.queue_id,
+                message=f"Error updating swap queue: {str(e)}",
+            )
+
+    def _build_swap_queue_call(self, new_call: dict, signer_account: str) -> dict:
+        """
+        Convert user-provided call payload into the enum expected by Substrate.
+        """
+        if not isinstance(new_call, dict):
+            raise ValueError("new_call must be a JSON object")
+
+        if "SwapToSubnetDelegateStake" in new_call:
+            payload = new_call["SwapToSubnetDelegateStake"]
+            if "to_subnet_id" not in payload:
+                raise ValueError(
+                    "to_subnet_id is required for SwapToSubnetDelegateStake"
+                )
+            to_subnet_id = int(payload["to_subnet_id"])
+            return {
+                "SwapToSubnetDelegateStake": {
+                    "account_id": payload.get("account_id", signer_account),
+                    "to_subnet_id": to_subnet_id,
+                    "balance": payload.get("balance", 0),
+                }
+            }
+
+        if "SwapToNodeDelegateStake" in new_call:
+            payload = new_call["SwapToNodeDelegateStake"]
+            if "to_subnet_id" not in payload or "to_subnet_node_id" not in payload:
+                raise ValueError(
+                    "to_subnet_id and to_subnet_node_id are required for SwapToNodeDelegateStake"
+                )
+            to_subnet_id = int(payload["to_subnet_id"])
+            to_subnet_node_id = int(payload["to_subnet_node_id"])
+            return {
+                "SwapToNodeDelegateStake": {
+                    "account_id": payload.get("account_id", signer_account),
+                    "to_subnet_id": to_subnet_id,
+                    "to_subnet_node_id": to_subnet_node_id,
+                    "balance": payload.get("balance", 0),
+                }
+            }
+
+        call_type = new_call.get("type") or new_call.get("call_type")
+        if not call_type:
+            raise ValueError("new_call must include 'type'")
+        normalized = call_type.strip()
+        if normalized not in (
+            "SwapToSubnetDelegateStake",
+            "SwapToNodeDelegateStake",
+        ):
+            raise ValueError(
+                "Unsupported call type. Use SwapToSubnetDelegateStake or SwapToNodeDelegateStake"
+            )
+
+        if normalized == "SwapToSubnetDelegateStake":
+            if "to_subnet_id" not in new_call:
+                raise ValueError(
+                    "to_subnet_id is required for SwapToSubnetDelegateStake"
+                )
+            to_subnet_id = int(new_call["to_subnet_id"])
+            return {
+                "SwapToSubnetDelegateStake": {
+                    "account_id": signer_account,
+                    "to_subnet_id": to_subnet_id,
+                    "balance": new_call.get("balance", 0),
+                }
+            }
+
+        if "to_subnet_id" not in new_call or "to_subnet_node_id" not in new_call:
+            raise ValueError(
+                "to_subnet_id and to_subnet_node_id are required for SwapToNodeDelegateStake"
+            )
+        to_subnet_id = int(new_call["to_subnet_id"])
+        to_subnet_node_id = int(new_call["to_subnet_node_id"])
+        return {
+            "SwapToNodeDelegateStake": {
+                "account_id": signer_account,
+                "to_subnet_id": to_subnet_id,
+                "to_subnet_node_id": to_subnet_node_id,
+                "balance": new_call.get("balance", 0),
+            }
+        }