htcli 1.1.0__py3-none-any.whl

src/htcli/client/rpc/wallet.py

@@ -0,0 +1,912 @@
+"""
+Wallet RPC operations for read-only queries.
+Handles balance checks, stake queries, and account information.
+"""
+
+from typing import Optional
+
+from substrateinterface import SubstrateInterface
+
+from ...models.responses import (
+    BalanceResponse,
+    ColdkeyStakesResponse,
+    ColdkeySubnetNodesResponse,
+    DelegateStakeInfo,
+    DelegateStakesResponse,
+    NodeDelegateStakeInfo,
+    NodeDelegateStakesResponse,
+    NodeStakeInfo,
+    SubnetNodeInfo,
+    SubnetNodeStakeInfo,
+    ValidatorStakesResponse,
+    ValidatorSubnetNodesResponse,
+)
+from ...utils.blockchain.type_registry import (
+    decode_vec_delegate_stake_info,
+    decode_vec_node_delegate_stake_info,
+    decode_vec_node_stake_info,
+    decode_vec_subnet_node_info,
+    decode_vec_subnet_node_stake_info,
+)
+from ...utils.logging import get_logger
+from ...utils.scale_codec import decode_hex_string, format_balance
+
+logger = get_logger(__name__)
+
+
+def _rpc_result_to_bytes(raw_data):
+    if isinstance(raw_data, str) and raw_data.startswith("0x"):
+        return bytes.fromhex(raw_data[2:])
+    if isinstance(raw_data, (bytes, bytearray)):
+        return bytes(raw_data)
+    if isinstance(raw_data, (list, tuple)) and all(
+        isinstance(item, int) for item in raw_data
+    ):
+        return bytes(raw_data)
+    return raw_data
+
+
+class WalletRpcClient:
+    """RPC client for wallet read-only operations."""
+
+    def __init__(self, substrate: SubstrateInterface):
+        self.substrate = substrate
+
+    def get_account_subnet_stake(self, account: str, subnet_id: int):
+        """Get account stake for a subnet using storage query."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # For now, use the account directly - proper SS58 handling can be added later
+            account_bytes = account
+
+            stake_data = self.substrate.query(
+                module="Network",
+                storage_function="AccountStake",
+                params=[account_bytes, subnet_id],
+            )
+
+            result = {
+                "success": True,
+                "message": "Account subnet stake retrieved successfully",
+                "data": {
+                    "account": account,
+                    "subnet_id": subnet_id,
+                    "stake": stake_data.value if stake_data else 0,
+                },
+            }
+
+            return result
+        except Exception as e:
+            logger.error(f"Failed to get account subnet stake: {str(e)}")
+            raise
+
+    def get_balance(self, address: str) -> BalanceResponse:
+        """Get account balance using System.Account storage query."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # Query account info directly
+            # Note: SubstrateInterface should have metadata loaded via init_runtime() in connect()
+            account_info = self.substrate.query("System", "Account", [address])
+
+            balance = (
+                account_info.value["data"]["free"]
+                if account_info and account_info.value
+                else 0
+            )
+
+            return BalanceResponse(
+                success=True,
+                transaction_hash=None,
+                error=None,
+                block_number=None,
+                epoch=None,
+                address=address,
+                balance=balance,
+                locked_balance=None,
+                available_balance=balance,
+                reserved_balance=None,
+            )
+        except Exception as e:
+            logger.error(f"Failed to get balance for {address}: {str(e)}")
+            raise
+
+    def get_delegate_stake_info(self, account: str, subnet_id: Optional[int] = None):
+        """Get delegate stake information for an account."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # For now, use the account directly - proper SS58 handling can be added later
+            account_bytes = account
+
+            if subnet_id is not None:
+                # Get stake for specific subnet
+                delegate_stake = self.substrate.query(
+                    module="Network",
+                    storage_function="DelegateStake",
+                    params=[account_bytes, subnet_id],
+                )
+
+                return {
+                    "success": True,
+                    "message": "Delegate stake info retrieved successfully",
+                    "data": {
+                        "account": account,
+                        "subnet_id": subnet_id,
+                        "delegate_stake": delegate_stake.value if delegate_stake else 0,
+                    },
+                }
+            else:
+                # Get all delegate stakes for account
+                # This would require iterating through all subnets or using a different storage function
+                return {
+                    "success": True,
+                    "message": "All delegate stakes query not implemented yet",
+                    "data": {
+                        "account": account,
+                        "message": "Use subnet_id parameter for specific subnet stake",
+                    },
+                }
+        except Exception as e:
+            logger.error(f"Failed to get delegate stake info: {str(e)}")
+            raise
+
+    def get_unbonding_info(self, account: str):
+        """Get unbonding information for an account."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # For now, use the account directly - proper SS58 handling can be added later
+            account_bytes = account
+
+            unbonding_data = self.substrate.query(
+                module="Network", storage_function="Unbondings", params=[account_bytes]
+            )
+
+            return {
+                "success": True,
+                "message": "Unbonding info retrieved successfully",
+                "data": {
+                    "account": account,
+                    "unbondings": unbonding_data.value if unbonding_data else [],
+                },
+            }
+        except Exception as e:
+            logger.error(f"Failed to get unbonding info: {str(e)}")
+            raise
+
+    def get_staking_summary(self, account: str):
+        """Get comprehensive staking summary for an account."""
+        try:
+            # Get balance
+            balance_info = self.get_balance(account)
+
+            # Get unbonding info
+            unbonding_info = self.get_unbonding_info(account)
+
+            return {
+                "success": True,
+                "message": "Staking summary retrieved successfully",
+                "data": {
+                    "account": account,
+                    "balance": balance_info.data,
+                    "unbondings": unbonding_info["data"]["unbondings"],
+                },
+            }
+        except Exception as e:
+            logger.error(f"Failed to get staking summary: {str(e)}")
+            raise
+
+    # RPC Methods Implementation
+    def network_get_coldkey_subnet_nodes_info(
+        self, coldkey: str, at: Optional[str] = None
+    ) -> ColdkeySubnetNodesResponse:
+        """RPC method: network_getColdkeySubnetNodesInfo - Returns subnet node info associated with a given coldkey account."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # Convert address to proper format for substrate
+            # Based on other RPC methods, we should use the address as-is or in hex format
+            if coldkey.startswith("0x"):
+                # EVM address format - use hex string without 0x prefix, normalize to lowercase
+                coldkey_param = coldkey[
+                    2:
+                ].lower()  # Remove 0x prefix and normalize case
+            else:
+                # SS58 address format - try to decode to hex
+                from substrateinterface.utils.ss58 import ss58_decode
+
+                try:
+                    coldkey_bytes = ss58_decode(coldkey)
+                    coldkey_param = coldkey_bytes.hex()
+                except Exception:
+                    # If SS58 decode fails, use address as-is
+                    coldkey_param = coldkey
+
+            params = [coldkey_param]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request(
+                "network_getColdkeySubnetNodesInfo", params
+            )
+
+            if result and result.get("result"):
+                # Get raw data and use proper SCALE decoding
+                raw_data = result["result"]
+                if isinstance(raw_data, str) and raw_data.startswith("0x"):
+                    hex_bytes = bytes.fromhex(raw_data[2:])
+                elif isinstance(raw_data, (list, tuple)):
+                    hex_bytes = bytes(raw_data)
+                else:
+                    hex_bytes = raw_data
+
+                # Use proper SCALE decoding for Vec<SubnetNodeInfo>
+                # Use the specialized decoder from type_registry which includes legacy fallback
+                try:
+                    decoded_list = decode_vec_subnet_node_info(hex_bytes)
+                    if not decoded_list:
+                        return ColdkeySubnetNodesResponse(
+                            success=True,
+                            message=f"No subnet nodes found for coldkey {coldkey}",
+                            data=[],
+                        )
+
+                    subnet_nodes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            # Decode text fields
+                            bootnode = decode_hex_string(
+                                decoded_data.get("bootnode", "")
+                            )
+                            unique = decode_hex_string(decoded_data.get("unique", ""))
+                            non_unique = decode_hex_string(
+                                decoded_data.get("non_unique", "")
+                            )
+                            # Format balances
+                            stake_balance_formatted = format_balance(
+                                decoded_data.get("stake_balance", 0)
+                            )
+                            delegate_stake_formatted = format_balance(
+                                decoded_data.get("node_delegate_stake_balance", 0)
+                            )
+
+                            node_data = {
+                                "subnet_id": decoded_data.get("subnet_id", 0),
+                                "subnet_node_id": decoded_data.get("subnet_node_id", 0),
+                                "coldkey": decoded_data.get("coldkey", ""),
+                                "hotkey": decoded_data.get("hotkey", ""),
+                                "peer_id": decoded_data.get("peer_id", ""),
+                                "bootnode_peer_id": decoded_data.get(
+                                    "bootnode_peer_id", ""
+                                ),
+                                "client_peer_id": decoded_data.get(
+                                    "client_peer_id", ""
+                                ),
+                                "bootnode": bootnode,
+                                "identity": decoded_data.get("identity", {}),
+                                "classification": decoded_data.get(
+                                    "classification", {}
+                                ),
+                                "delegate_reward_rate": decoded_data.get(
+                                    "delegate_reward_rate", 0
+                                ),
+                                "last_delegate_reward_rate_update": decoded_data.get(
+                                    "last_delegate_reward_rate_update", 0
+                                ),
+                                "unique": unique,
+                                "non_unique": non_unique,
+                                "stake_balance": decoded_data.get("stake_balance", 0),
+                                "stake_balance_formatted": stake_balance_formatted,
+                                "node_delegate_stake_balance": decoded_data.get(
+                                    "node_delegate_stake_balance", 0
+                                ),
+                                "                                node_delegate_stake_balance_formatted": delegate_stake_formatted,
+                                "coldkey_reputation": decoded_data.get(
+                                    "coldkey_reputation", {}
+                                ),
+                                "subnet_node_reputation": decoded_data.get(
+                                    "subnet_node_reputation", 0
+                                ),
+                            }
+
+                            subnet_nodes.append(SubnetNodeInfo(**node_data))
+
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to decode node data for coldkey {coldkey}: {e}"
+                            )
+                            continue
+
+                except Exception as decode_error:
+                    # Log at debug level to avoid cluttering output
+                    logger.debug(
+                        f"SCALE decoding failed for coldkey {coldkey}, falling back to manual parsing: {decode_error}"
+                    )
+                    # Fallback to manual parsing
+                    nodes_data = raw_data
+                    if isinstance(nodes_data, list):
+                        # Check if the list contains dictionaries (proper node data)
+                        if nodes_data and isinstance(nodes_data[0], dict):
+                            subnet_nodes = [
+                                SubnetNodeInfo(**node_data) for node_data in nodes_data
+                            ]
+                        else:
+                            # Handle case where result is a list of non-dict items (e.g., [0])
+                            subnet_nodes = []
+                    else:
+                        # Handle case where result is not a list (e.g., single integer)
+                        subnet_nodes = []
+
+                return ColdkeySubnetNodesResponse(
+                    success=True,
+                    message=f"Coldkey {coldkey} subnet nodes info retrieved successfully",
+                    data=subnet_nodes,
+                )
+            else:
+                return ColdkeySubnetNodesResponse(
+                    success=False,
+                    message=f"No subnet nodes found for coldkey {coldkey}",
+                    data=[],
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to get coldkey subnet nodes info via RPC for {coldkey}: {str(e)}"
+            )
+            return ColdkeySubnetNodesResponse(
+                success=False,
+                message=f"Failed to get coldkey subnet nodes info: {str(e)}",
+                data=None,
+            )
+
+    def network_get_validator_subnet_nodes_info(
+        self, validator_id: int, at: Optional[str] = None
+    ) -> ValidatorSubnetNodesResponse:
+        """RPC method: network_getValidatorSubnetNodesInfo."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            params = [validator_id]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request(
+                "network_getValidatorSubnetNodesInfo", params
+            )
+
+            if result and result.get("result"):
+                raw_data = result["result"]
+                rpc_bytes = _rpc_result_to_bytes(raw_data)
+
+                try:
+                    decoded_list = decode_vec_subnet_node_info(rpc_bytes)
+                    if not decoded_list:
+                        return ValidatorSubnetNodesResponse(
+                            success=True,
+                            message=(
+                                f"No subnet nodes found for validator {validator_id}"
+                            ),
+                            data=[],
+                        )
+
+                    subnet_nodes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            bootnode = decode_hex_string(
+                                decoded_data.get("bootnode", "")
+                            )
+                            unique = decode_hex_string(decoded_data.get("unique", ""))
+                            non_unique = decode_hex_string(
+                                decoded_data.get("non_unique", "")
+                            )
+
+                            node_data = {
+                                "subnet_id": decoded_data.get("subnet_id", 0),
+                                "subnet_node_id": decoded_data.get("subnet_node_id", 0),
+                                "coldkey": decoded_data.get("coldkey", ""),
+                                "hotkey": decoded_data.get("hotkey", ""),
+                                "peer_id": decoded_data.get("peer_id", ""),
+                                "bootnode_peer_id": decoded_data.get(
+                                    "bootnode_peer_id", ""
+                                ),
+                                "client_peer_id": decoded_data.get(
+                                    "client_peer_id", ""
+                                ),
+                                "bootnode": bootnode,
+                                "identity": decoded_data.get("identity", {}),
+                                "classification": decoded_data.get(
+                                    "classification", {}
+                                ),
+                                "delegate_reward_rate": decoded_data.get(
+                                    "delegate_reward_rate", 0
+                                ),
+                                "last_delegate_reward_rate_update": decoded_data.get(
+                                    "last_delegate_reward_rate_update", 0
+                                ),
+                                "unique": unique,
+                                "non_unique": non_unique,
+                                "stake_balance": decoded_data.get("stake_balance", 0),
+                                "node_delegate_stake_balance": decoded_data.get(
+                                    "node_delegate_stake_balance", 0
+                                ),
+                                "coldkey_reputation": decoded_data.get(
+                                    "coldkey_reputation", {}
+                                ),
+                                "subnet_node_reputation": decoded_data.get(
+                                    "subnet_node_reputation", 0
+                                ),
+                            }
+                            subnet_nodes.append(SubnetNodeInfo(**node_data))
+                        except Exception as e:
+                            logger.warning(
+                                "Failed to decode node data for validator "
+                                f"{validator_id}: {e}"
+                            )
+                            continue
+
+                except Exception as decode_error:
+                    logger.debug(
+                        "SCALE decoding failed for validator subnet nodes "
+                        f"{validator_id}, trying fallback: {decode_error}"
+                    )
+                    if (
+                        isinstance(raw_data, list)
+                        and raw_data
+                        and isinstance(raw_data[0], dict)
+                    ):
+                        subnet_nodes = [
+                            SubnetNodeInfo(**node_data) for node_data in raw_data
+                        ]
+                    else:
+                        subnet_nodes = []
+
+                return ValidatorSubnetNodesResponse(
+                    success=True,
+                    message=(
+                        f"Validator {validator_id} subnet nodes info retrieved "
+                        "successfully"
+                    ),
+                    data=subnet_nodes,
+                )
+
+            return ValidatorSubnetNodesResponse(
+                success=False,
+                message=f"No subnet nodes found for validator {validator_id}",
+                data=[],
+            )
+        except Exception as e:
+            logger.error(
+                "Failed to get validator subnet nodes info via RPC for "
+                f"{validator_id}: {str(e)}"
+            )
+            return ValidatorSubnetNodesResponse(
+                success=False,
+                message=f"Failed to get validator subnet nodes info: {str(e)}",
+                data=None,
+            )
+
+    def network_get_coldkey_stakes(
+        self, coldkey: str, at: Optional[str] = None
+    ) -> ColdkeyStakesResponse:
+        """RPC method: network_getColdkeyStakes - Fetches stake information for a given coldkey."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # Convert address to proper format for substrate (manual conversion works reliably)
+            if coldkey.startswith("0x"):
+                # EVM address format - convert to hex string
+                coldkey_hex = coldkey[2:]  # Remove 0x prefix
+            else:
+                # SS58 address format - decode to hex string
+                from substrateinterface.utils.ss58 import ss58_decode
+
+                try:
+                    coldkey_bytes = ss58_decode(coldkey)
+                    coldkey_hex = coldkey_bytes.hex()
+                except Exception:
+                    # If SS58 decode fails, try to use address as-is
+                    coldkey_hex = coldkey
+
+            params = [coldkey_hex]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request("network_getColdkeyStakes", params)
+
+            if result and result.get("result"):
+                # Get raw data and decode SCALE-encoded bytes
+                raw_data = result["result"]
+                if isinstance(raw_data, str) and raw_data.startswith("0x"):
+                    hex_bytes = bytes.fromhex(raw_data[2:])
+                elif isinstance(raw_data, (list, tuple)):
+                    hex_bytes = bytes(raw_data)
+                else:
+                    hex_bytes = raw_data
+
+                # Use proper SCALE decoding for Vec<SubnetNodeStakeInfo>
+                try:
+                    decoded_list = decode_vec_subnet_node_stake_info(hex_bytes)
+                    if not decoded_list:
+                        return ColdkeyStakesResponse(
+                            success=True,
+                            message=f"No stakes found for coldkey {coldkey}",
+                            data=[],
+                        )
+
+                    stakes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            stake_info = SubnetNodeStakeInfo(
+                                subnet_id=decoded_data.get("subnet_id"),
+                                subnet_node_id=decoded_data.get("subnet_node_id"),
+                                hotkey=decoded_data.get("hotkey", ""),
+                                balance=decoded_data.get("balance", 0),
+                            )
+                            stakes.append(stake_info)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to decode stake data for coldkey {coldkey}: {e}"
+                            )
+                            continue
+
+                    return ColdkeyStakesResponse(
+                        success=True,
+                        message=f"Coldkey {coldkey} stakes retrieved successfully",
+                        data=stakes,
+                    )
+                except Exception as decode_error:
+                    logger.debug(
+                        f"SCALE decoding failed for coldkey stakes {coldkey}, trying fallback: {decode_error}"
+                    )
+                    # Fallback: try to parse as already-decoded data
+                    if (
+                        isinstance(raw_data, list)
+                        and raw_data
+                        and isinstance(raw_data[0], dict)
+                    ):
+                        stakes = [
+                            SubnetNodeStakeInfo(**stake_data) for stake_data in raw_data
+                        ]
+                        return ColdkeyStakesResponse(
+                            success=True,
+                            message=f"Coldkey {coldkey} stakes retrieved successfully",
+                            data=stakes,
+                        )
+                    return ColdkeyStakesResponse(
+                        success=True,
+                        message=f"No stakes found for coldkey {coldkey}",
+                        data=[],
+                    )
+            else:
+                return ColdkeyStakesResponse(
+                    success=False,
+                    message=f"No stakes found for coldkey {coldkey}",
+                    data=[],
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to get coldkey stakes via RPC for {coldkey}: {str(e)}"
+            )
+            return ColdkeyStakesResponse(
+                success=False,
+                message=f"Failed to get coldkey stakes: {str(e)}",
+                data=None,
+            )
+
+    def network_get_validator_stakes(
+        self, validator_id: int, at: Optional[str] = None
+    ) -> ValidatorStakesResponse:
+        """RPC method: network_getValidatorStakes - Fetches stake information for a validator."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            params = [validator_id]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request("network_getValidatorStakes", params)
+
+            if result and result.get("result"):
+                raw_data = result["result"]
+                rpc_bytes = _rpc_result_to_bytes(raw_data)
+
+                try:
+                    decoded_list = decode_vec_node_stake_info(rpc_bytes)
+                    if not decoded_list:
+                        return ValidatorStakesResponse(
+                            success=True,
+                            message=f"No stakes found for validator {validator_id}",
+                            data=[],
+                        )
+
+                    stakes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            stake_info = NodeStakeInfo(
+                                subnet_id=decoded_data.get("subnet_id"),
+                                subnet_node_id=decoded_data.get("subnet_node_id"),
+                                balance=decoded_data.get("balance", 0),
+                            )
+                            stakes.append(stake_info)
+                        except Exception as e:
+                            logger.warning(
+                                "Failed to decode stake data for validator "
+                                f"{validator_id}: {e}"
+                            )
+                            continue
+
+                    return ValidatorStakesResponse(
+                        success=True,
+                        message=(
+                            f"Validator {validator_id} stakes retrieved successfully"
+                        ),
+                        data=stakes,
+                    )
+                except Exception as decode_error:
+                    logger.debug(
+                        "SCALE decoding failed for validator stakes "
+                        f"{validator_id}, trying fallback: {decode_error}"
+                    )
+                    if (
+                        isinstance(raw_data, list)
+                        and raw_data
+                        and isinstance(raw_data[0], dict)
+                    ):
+                        stakes = [
+                            NodeStakeInfo(**stake_data) for stake_data in raw_data
+                        ]
+                        return ValidatorStakesResponse(
+                            success=True,
+                            message=(
+                                f"Validator {validator_id} stakes retrieved "
+                                "successfully"
+                            ),
+                            data=stakes,
+                        )
+                    return ValidatorStakesResponse(
+                        success=True,
+                        message=f"No stakes found for validator {validator_id}",
+                        data=[],
+                    )
+
+            return ValidatorStakesResponse(
+                success=False,
+                message=f"No stakes found for validator {validator_id}",
+                data=[],
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to get validator stakes via RPC for {validator_id}: {str(e)}"
+            )
+            return ValidatorStakesResponse(
+                success=False,
+                message=f"Failed to get validator stakes: {str(e)}",
+                data=None,
+            )
+
+    def network_get_delegate_stakes(
+        self, account_id: str, at: Optional[str] = None
+    ) -> DelegateStakesResponse:
+        """RPC method: network_getDelegateStakes - Returns delegate stakes associated with an account."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # Convert address to proper format for substrate (manual conversion works reliably)
+            if account_id.startswith("0x"):
+                # EVM address format - convert to hex string
+                account_hex = account_id[2:]  # Remove 0x prefix
+            else:
+                # SS58 address format - decode to hex string
+                from substrateinterface.utils.ss58 import ss58_decode
+
+                try:
+                    account_bytes = ss58_decode(account_id)
+                    account_hex = account_bytes.hex()
+                except Exception:
+                    # If SS58 decode fails, try to use address as-is
+                    account_hex = account_id
+
+            params = [account_hex]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request("network_getDelegateStakes", params)
+
+            if result and result.get("result"):
+                # Get raw data and decode SCALE-encoded bytes
+                raw_data = result["result"]
+                if isinstance(raw_data, str) and raw_data.startswith("0x"):
+                    hex_bytes = bytes.fromhex(raw_data[2:])
+                elif isinstance(raw_data, (list, tuple)):
+                    hex_bytes = bytes(raw_data)
+                else:
+                    hex_bytes = raw_data
+
+                # Use proper SCALE decoding for Vec<DelegateStakeInfo>
+                try:
+                    decoded_list = decode_vec_delegate_stake_info(hex_bytes)
+                    if not decoded_list:
+                        return DelegateStakesResponse(
+                            success=True,
+                            message=f"No delegate stakes found for account {account_id}",
+                            data=[],
+                        )
+
+                    stakes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            stake_info = DelegateStakeInfo(
+                                subnet_id=decoded_data.get("subnet_id", 0),
+                                shares=decoded_data.get("shares", 0),
+                                balance=decoded_data.get("balance", 0),
+                            )
+                            stakes.append(stake_info)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to decode delegate stake data for account {account_id}: {e}"
+                            )
+                            continue
+
+                    return DelegateStakesResponse(
+                        success=True,
+                        message=f"Delegate stakes for account {account_id} retrieved successfully",
+                        data=stakes,
+                    )
+                except Exception as decode_error:
+                    logger.debug(
+                        f"SCALE decoding failed for delegate stakes {account_id}, trying fallback: {decode_error}"
+                    )
+                    # Fallback: try to parse as already-decoded data
+                    if (
+                        isinstance(raw_data, list)
+                        and raw_data
+                        and isinstance(raw_data[0], dict)
+                    ):
+                        stakes = [
+                            DelegateStakeInfo(**stake_data) for stake_data in raw_data
+                        ]
+                        return DelegateStakesResponse(
+                            success=True,
+                            message=f"Delegate stakes for account {account_id} retrieved successfully",
+                            data=stakes,
+                        )
+                    return DelegateStakesResponse(
+                        success=True,
+                        message=f"No delegate stakes found for account {account_id}",
+                        data=[],
+                    )
+            else:
+                return DelegateStakesResponse(
+                    success=False,
+                    message=f"No delegate stakes found for account {account_id}",
+                    data=[],
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to get delegate stakes via RPC for {account_id}: {str(e)}"
+            )
+            return DelegateStakesResponse(
+                success=False,
+                message=f"Failed to get delegate stakes: {str(e)}",
+                data=None,
+            )
+
+    def network_get_node_delegate_stakes(
+        self, account_id: str, at: Optional[str] = None
+    ) -> NodeDelegateStakesResponse:
+        """RPC method: network_getNodeDelegateStakes - Fetches delegate stake info specifically for nodes linked to an account."""
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            # Convert address to proper format for substrate (manual conversion works reliably)
+            if account_id.startswith("0x"):
+                # EVM address format - convert to hex string
+                account_hex = account_id[2:]  # Remove 0x prefix
+            else:
+                # SS58 address format - decode to hex string
+                from substrateinterface.utils.ss58 import ss58_decode
+
+                try:
+                    account_bytes = ss58_decode(account_id)
+                    account_hex = account_bytes.hex()
+                except Exception:
+                    # If SS58 decode fails, try to use address as-is
+                    account_hex = account_id
+
+            params = [account_hex]
+            if at:
+                params.append(at)
+
+            result = self.substrate.rpc_request("network_getNodeDelegateStakes", params)
+
+            if result and result.get("result"):
+                # Get raw data and decode SCALE-encoded bytes
+                raw_data = result["result"]
+                if isinstance(raw_data, str) and raw_data.startswith("0x"):
+                    hex_bytes = bytes.fromhex(raw_data[2:])
+                elif isinstance(raw_data, (list, tuple)):
+                    hex_bytes = bytes(raw_data)
+                else:
+                    hex_bytes = raw_data
+
+                # Use proper SCALE decoding for Vec<NodeDelegateStakeInfo>
+                try:
+                    decoded_list = decode_vec_node_delegate_stake_info(hex_bytes)
+                    if not decoded_list:
+                        return NodeDelegateStakesResponse(
+                            success=True,
+                            message=f"No node delegate stakes found for account {account_id}",
+                            data=[],
+                        )
+
+                    stakes = []
+                    for decoded_data in decoded_list:
+                        try:
+                            stake_info = NodeDelegateStakeInfo(
+                                subnet_id=decoded_data.get("subnet_id", 0),
+                                subnet_node_id=decoded_data.get("subnet_node_id", 0),
+                                shares=decoded_data.get("shares", 0),
+                                balance=decoded_data.get("balance", 0),
+                            )
+                            stakes.append(stake_info)
+                        except Exception as e:
+                            logger.warning(
+                                f"Failed to decode node delegate stake data for account {account_id}: {e}"
+                            )
+                            continue
+
+                    return NodeDelegateStakesResponse(
+                        success=True,
+                        message=f"Node delegate stakes for account {account_id} retrieved successfully",
+                        data=stakes,
+                    )
+                except Exception as decode_error:
+                    logger.debug(
+                        f"SCALE decoding failed for node delegate stakes {account_id}, trying fallback: {decode_error}"
+                    )
+                    # Fallback: try to parse as already-decoded data
+                    if (
+                        isinstance(raw_data, list)
+                        and raw_data
+                        and isinstance(raw_data[0], dict)
+                    ):
+                        stakes = [
+                            NodeDelegateStakeInfo(**stake_data)
+                            for stake_data in raw_data
+                        ]
+                        return NodeDelegateStakesResponse(
+                            success=True,
+                            message=f"Node delegate stakes for account {account_id} retrieved successfully",
+                            data=stakes,
+                        )
+                    return NodeDelegateStakesResponse(
+                        success=True,
+                        message=f"No node delegate stakes found for account {account_id}",
+                        data=[],
+                    )
+            else:
+                return NodeDelegateStakesResponse(
+                    success=False,
+                    message=f"No node delegate stakes found for account {account_id}",
+                    data=[],
+                )
+        except Exception as e:
+            logger.error(
+                f"Failed to get node delegate stakes via RPC for {account_id}: {str(e)}"
+            )
+            return NodeDelegateStakesResponse(
+                success=False,
+                message=f"Failed to get node delegate stakes: {str(e)}",
+                data=None,
+            )