htcli 1.1.0__py3-none-any.whl

src/htcli/client/rpc/node.py

@@ -0,0 +1,783 @@
+"""
+RPC client for subnet node-related queries using scalecodec for decoding.
+"""
+
+from typing import Optional
+
+from substrateinterface import SubstrateInterface
+
+from ...models.responses import SubnetNodeInfo
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class SubnetNodeRpcClient:
+    """RPC client for subnet node-related queries."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the subnet node RPC client."""
+        self.substrate = substrate
+
+    def get_subnet_node_info(
+        self, subnet_id: int, subnet_node_id: int
+    ) -> Optional[SubnetNodeInfo]:
+        """
+        Get subnet node information using custom RPC method with full SCALE decoding.
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_node_id: The subnet node ID
+
+        Returns:
+            SubnetNodeInfo with all fields decoded, or None if not found
+
+        Reference:
+            - mesh-template chain_functions.py lines 1843-1864, 2090-2107
+            - hypertensor-evm/pallets/network/src/lib.rs lines 1184-1203
+        """
+        # Check if substrate connection exists
+        if self.substrate is None:
+            logger.error("Cannot get subnet node info: not connected to blockchain")
+            raise RuntimeError("Not connected to blockchain")
+
+        try:
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getSubnetNodeInfo", params=[subnet_id, subnet_node_id]
+            )
+
+            if not result or not result.get("result"):
+                return None
+
+            result_data = result["result"]
+
+            # Decode Option<SubnetNodeInfo> using custom type registry
+            from ...utils.blockchain.type_registry import decode_option_subnet_node_info
+
+            decoded = decode_option_subnet_node_info(result_data)
+
+            if decoded is None:
+                return None
+
+            # Convert decoded dict to SubnetNodeInfo model
+            def to_bytes(val):
+                """Convert decoded value to bytes for peer IDs and other byte fields."""
+                if isinstance(val, bytes):
+                    return val
+                if isinstance(val, list):
+                    # Vec<u8> from SCALE decoding is a list of integers (0-255)
+                    # Convert to bytes
+                    try:
+                        return bytes(val)
+                    except (ValueError, TypeError):
+                        # If conversion fails, try to convert each element
+                        return bytes(int(b) for b in val if 0 <= int(b) <= 255)
+                if isinstance(val, str):
+                    # String peer IDs should be encoded to UTF-8 bytes
+                    return val.encode("utf-8")
+                # Default: return empty bytes
+                return b""
+
+            def to_address(val):
+                from ...utils.blockchain.formatting import to_checksum_address
+
+                if isinstance(val, str):
+                    raw_addr = val if val.startswith("0x") else "0x" + val
+                else:
+                    raw_addr = "0x" + (
+                        bytes(val).hex() if isinstance(val, (list, bytes)) else ""
+                    )
+                return to_checksum_address(raw_addr)
+
+            # Extract classification (it's a dict with node_class and start_epoch)
+            classification_data = decoded.get("classification", {})
+
+            return SubnetNodeInfo(
+                subnet_id=decoded["subnet_id"],
+                subnet_node_id=decoded["subnet_node_id"],
+                coldkey=to_address(decoded["coldkey"]),
+                hotkey=to_address(decoded["hotkey"]),
+                peer_id=to_bytes(decoded.get("peer_id", b"")),
+                bootnode_peer_id=to_bytes(decoded.get("bootnode_peer_id", b"")),
+                client_peer_id=to_bytes(decoded.get("client_peer_id", b"")),
+                bootnode=(
+                    to_bytes(decoded.get("bootnode"))
+                    if decoded.get("bootnode")
+                    else None
+                ),
+                identity=decoded.get("identity"),
+                classification=classification_data,  # Pass dict as-is
+                delegate_reward_rate=decoded.get("delegate_reward_rate", 0),
+                last_delegate_reward_rate_update=decoded.get(
+                    "last_delegate_reward_rate_update", 0
+                ),
+                unique=(
+                    to_bytes(decoded.get("unique")) if decoded.get("unique") else None
+                ),
+                non_unique=(
+                    to_bytes(decoded.get("non_unique"))
+                    if decoded.get("non_unique")
+                    else None
+                ),
+                stake_balance=decoded.get("stake_balance", 0),
+                total_node_delegate_stake_shares=decoded.get(
+                    "total_node_delegate_stake_shares", 0
+                ),
+                node_delegate_stake_balance=decoded.get(
+                    "node_delegate_stake_balance", 0
+                ),
+                coldkey_reputation=decoded.get("coldkey_reputation"),
+                subnet_node_reputation=decoded.get("subnet_node_reputation", 0),
+                node_slot_index=decoded.get("node_slot_index"),
+                consecutive_idle_epochs=decoded.get("consecutive_idle_epochs", 0),
+                consecutive_included_epochs=decoded.get(
+                    "consecutive_included_epochs", 0
+                ),
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting subnet node info: {e}")
+            return None
+
+    def get_subnet_nodes_info(self, subnet_id: int) -> list[SubnetNodeInfo]:
+        """
+        Get information about all nodes in a subnet using custom RPC method with full SCALE decoding.
+
+        Args:
+            subnet_id: The subnet ID
+
+        Returns:
+            List of SubnetNodeInfo objects with all fields decoded
+
+        Reference:
+            - mesh-template chain_functions.py lines 1619-1634, 2109-2124
+            - hypertensor-evm/pallets/network/src/rpc_info/info.rs lines 148+
+        """
+        # Check if substrate connection exists
+        if self.substrate is None:
+            logger.error("Cannot get subnet nodes info: not connected to blockchain")
+            raise RuntimeError("Not connected to blockchain")
+
+        try:
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getSubnetNodesInfo", params=[subnet_id]
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            result_data = result["result"]
+
+            # Decode Vec<SubnetNodeInfo> using custom type registry
+            from ...utils.blockchain.type_registry import decode_vec_subnet_node_info
+
+            decoded_list = decode_vec_subnet_node_info(result_data)
+
+            if not decoded_list:
+                # Try fallback method when Vec decode returns nothing
+                fallback_nodes = self._get_subnet_nodes_info_fallback(subnet_id, [])
+                if fallback_nodes:
+                    return fallback_nodes
+                return []
+
+            # Convert to list of SubnetNodeInfo objects
+            def to_bytes(val):
+                """Convert decoded value to bytes for peer IDs and other byte fields."""
+                if isinstance(val, bytes):
+                    return val
+                if isinstance(val, list):
+                    # Vec<u8> from SCALE decoding is a list of integers (0-255)
+                    # Convert to bytes
+                    try:
+                        return bytes(val)
+                    except (ValueError, TypeError):
+                        # If conversion fails, try to convert each element
+                        return bytes(int(b) for b in val if 0 <= int(b) <= 255)
+                if isinstance(val, str):
+                    # String peer IDs should be encoded to UTF-8 bytes
+                    return val.encode("utf-8")
+                # Default: return empty bytes
+                return b""
+
+            def to_address(val):
+                from ...utils.blockchain.formatting import to_checksum_address
+
+                if isinstance(val, str):
+                    raw_addr = val if val.startswith("0x") else "0x" + val
+                else:
+                    raw_addr = "0x" + (
+                        bytes(val).hex() if isinstance(val, (list, bytes)) else ""
+                    )
+                return to_checksum_address(raw_addr)
+
+            nodes = []
+            for idx, decoded in enumerate(decoded_list):
+                try:
+                    classification_data = decoded.get("classification", {})
+
+                    node_info = SubnetNodeInfo(
+                        subnet_id=decoded["subnet_id"],
+                        subnet_node_id=decoded["subnet_node_id"],
+                        coldkey=to_address(decoded["coldkey"]),
+                        hotkey=to_address(decoded["hotkey"]),
+                        peer_id=to_bytes(decoded["peer_id"]),
+                        bootnode_peer_id=to_bytes(decoded["bootnode_peer_id"]),
+                        client_peer_id=to_bytes(decoded["client_peer_id"]),
+                        bootnode=(
+                            to_bytes(decoded.get("bootnode"))
+                            if decoded.get("bootnode")
+                            else None
+                        ),
+                        identity=decoded.get("identity"),
+                        classification=classification_data,  # Pass dict as-is
+                        delegate_reward_rate=decoded.get("delegate_reward_rate", 0),
+                        last_delegate_reward_rate_update=decoded.get(
+                            "last_delegate_reward_rate_update", 0
+                        ),
+                        unique=(
+                            to_bytes(decoded.get("unique"))
+                            if decoded.get("unique")
+                            else None
+                        ),
+                        non_unique=(
+                            to_bytes(decoded.get("non_unique"))
+                            if decoded.get("non_unique")
+                            else None
+                        ),
+                        stake_balance=decoded.get("stake_balance", 0),
+                        node_delegate_stake_balance=decoded.get(
+                            "node_delegate_stake_balance", 0
+                        ),
+                        total_node_delegate_stake_shares=decoded.get(
+                            "total_node_delegate_stake_shares", 0
+                        ),
+                        coldkey_reputation=decoded.get("coldkey_reputation"),
+                        subnet_node_reputation=decoded.get("subnet_node_reputation", 0),
+                        node_slot_index=decoded.get("node_slot_index"),
+                        consecutive_idle_epochs=decoded.get(
+                            "consecutive_idle_epochs", 0
+                        ),
+                        consecutive_included_epochs=decoded.get(
+                            "consecutive_included_epochs", 0
+                        ),
+                    )
+                    nodes.append(node_info)
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to convert node info (idx={idx}, subnet_id={decoded.get('subnet_id')}, node_id={decoded.get('subnet_node_id')}): {e}"
+                    )
+                    continue
+
+            # Fallback: If we got fewer nodes than expected (or Vec decode seems incomplete),
+            # try querying individual nodes sequentially
+            # Check data size to see if there might be more nodes
+            data_size = len(result_data) if hasattr(result_data, "__len__") else 0
+            if len(nodes) <= 2 and data_size > 100:
+                fallback_nodes = self._get_subnet_nodes_info_fallback(subnet_id, nodes)
+                if fallback_nodes and len(fallback_nodes) > len(nodes):
+                    return fallback_nodes
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error getting subnet nodes info: {e}")
+            import traceback
+
+            logger.debug(traceback.format_exc())
+            # Try fallback method even on exception
+            try:
+                fallback_nodes = self._get_subnet_nodes_info_fallback(subnet_id, [])
+                if fallback_nodes:
+                    return fallback_nodes
+            except Exception as fallback_error:
+                logger.debug(f"Fallback method also failed: {fallback_error}")
+            return []
+
+    def _get_subnet_nodes_info_fallback(
+        self, subnet_id: int, existing_nodes: list[SubnetNodeInfo]
+    ) -> list[SubnetNodeInfo]:
+        """
+        Fallback method: Query individual nodes one by one starting from node_id=1
+        until we hit a non-existent node.
+
+        Args:
+            subnet_id: The subnet ID
+            existing_nodes: Already found nodes from Vec decode (to avoid duplicates)
+
+        Returns:
+            List of all SubnetNodeInfo objects found
+        """
+        nodes = []
+        existing_node_ids = {node.subnet_node_id for node in existing_nodes}
+
+        # Start from node_id=1 and increment until we hit a non-existent node
+        node_id = 1
+        consecutive_not_found = 0
+        max_consecutive_not_found = 5  # Stop after 5 consecutive non-existent nodes
+        max_nodes = 1000  # Safety limit to prevent infinite loops
+
+        while (
+            node_id <= max_nodes and consecutive_not_found < max_consecutive_not_found
+        ):
+            # Skip if we already have this node from Vec decode
+            if node_id in existing_node_ids:
+                node_id += 1
+                consecutive_not_found = 0  # Reset counter when we find an existing one
+                continue
+
+            try:
+                node_info = self.get_subnet_node_info(subnet_id, node_id)
+                if node_info:
+                    nodes.append(node_info)
+                    consecutive_not_found = 0  # Reset counter on success
+                else:
+                    consecutive_not_found += 1
+                    if consecutive_not_found >= max_consecutive_not_found:
+                        break
+            except Exception:
+                consecutive_not_found += 1
+                if consecutive_not_found >= max_consecutive_not_found:
+                    break
+
+            node_id += 1
+
+        # Combine with existing nodes, removing duplicates
+        all_nodes = existing_nodes + nodes
+        # Remove duplicates by subnet_node_id (keep first occurrence)
+        seen_ids = set()
+        unique_nodes = []
+        for node in all_nodes:
+            if node.subnet_node_id not in seen_ids:
+                seen_ids.add(node.subnet_node_id)
+                unique_nodes.append(node)
+
+        # Sort by node_id for consistency
+        unique_nodes.sort(key=lambda x: x.subnet_node_id)
+
+        return unique_nodes
+
+    def get_all_subnet_nodes_info(self) -> list[SubnetNodeInfo]:
+        """
+        Get information about all subnet nodes across all subnets using custom RPC method with full SCALE decoding.
+
+        Returns:
+            List of SubnetNodeInfo objects with all fields decoded
+
+        Reference:
+            - mesh-template chain_functions.py lines 1636-1650, 2126-2141
+        """
+        # Check if substrate connection exists
+        if self.substrate is None:
+            logger.error(
+                "Cannot get all subnet nodes info: not connected to blockchain"
+            )
+            raise RuntimeError("Not connected to blockchain")
+
+        try:
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getAllSubnetNodesInfo", params=[]
+            )
+
+            if not result or not result.get("result"):
+                logger.warning(
+                    "RPC request returned no result for getAllSubnetNodesInfo"
+                )
+                return []
+
+            result_data = result["result"]
+
+            # Decode Vec<SubnetNodeInfo> using custom type registry
+            from ...utils.blockchain.type_registry import decode_vec_subnet_node_info
+
+            decoded_list = decode_vec_subnet_node_info(result_data)
+
+            if not decoded_list:
+                logger.info("No nodes found across all subnets")
+                return []
+
+            # Convert to list of SubnetNodeInfo objects (same logic as get_subnet_nodes_info)
+            def to_bytes(val):
+                """Convert decoded value to bytes for peer IDs and other byte fields."""
+                if isinstance(val, bytes):
+                    return val
+                if isinstance(val, list):
+                    # Vec<u8> from SCALE decoding is a list of integers (0-255)
+                    # Convert to bytes
+                    try:
+                        return bytes(val)
+                    except (ValueError, TypeError):
+                        # If conversion fails, try to convert each element
+                        return bytes(int(b) for b in val if 0 <= int(b) <= 255)
+                if isinstance(val, str):
+                    # String peer IDs should be encoded to UTF-8 bytes
+                    return val.encode("utf-8")
+                # Default: return empty bytes
+                return b""
+
+            def to_address(val):
+                from ...utils.blockchain.formatting import to_checksum_address
+
+                if isinstance(val, str):
+                    raw_addr = val if val.startswith("0x") else "0x" + val
+                else:
+                    raw_addr = "0x" + (
+                        bytes(val).hex() if isinstance(val, (list, bytes)) else ""
+                    )
+                return to_checksum_address(raw_addr)
+
+            nodes = []
+            for decoded in decoded_list:
+                try:
+                    classification_data = decoded.get("classification", {})
+
+                    node_info = SubnetNodeInfo(
+                        subnet_id=decoded["subnet_id"],
+                        subnet_node_id=decoded["subnet_node_id"],
+                        coldkey=to_address(decoded["coldkey"]),
+                        hotkey=to_address(decoded["hotkey"]),
+                        peer_id=to_bytes(decoded["peer_id"]),
+                        bootnode_peer_id=to_bytes(decoded["bootnode_peer_id"]),
+                        client_peer_id=to_bytes(decoded["client_peer_id"]),
+                        bootnode=(
+                            to_bytes(decoded.get("bootnode"))
+                            if decoded.get("bootnode")
+                            else None
+                        ),
+                        identity=decoded.get("identity"),
+                        classification=classification_data,  # Pass dict as-is
+                        delegate_reward_rate=decoded.get("delegate_reward_rate", 0),
+                        last_delegate_reward_rate_update=decoded.get(
+                            "last_delegate_reward_rate_update", 0
+                        ),
+                        unique=(
+                            to_bytes(decoded.get("unique"))
+                            if decoded.get("unique")
+                            else None
+                        ),
+                        non_unique=(
+                            to_bytes(decoded.get("non_unique"))
+                            if decoded.get("non_unique")
+                            else None
+                        ),
+                        stake_balance=decoded.get("stake_balance", 0),
+                        node_delegate_stake_balance=decoded.get(
+                            "node_delegate_stake_balance", 0
+                        ),
+                        total_node_delegate_stake_shares=decoded.get(
+                            "total_node_delegate_stake_shares", 0
+                        ),
+                        coldkey_reputation=decoded.get("coldkey_reputation"),
+                        subnet_node_reputation=decoded.get("subnet_node_reputation", 0),
+                        node_slot_index=decoded.get("node_slot_index"),
+                        consecutive_idle_epochs=decoded.get(
+                            "consecutive_idle_epochs", 0
+                        ),
+                        consecutive_included_epochs=decoded.get(
+                            "consecutive_included_epochs", 0
+                        ),
+                    )
+                    nodes.append(node_info)
+                except Exception as e:
+                    logger.warning(f"Failed to convert node info: {e}")
+                    continue
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error getting all subnet nodes info: {e}")
+            logger.error(f"Error type: {type(e).__name__}")
+            raise  # Re-raise the exception so handler can catch it
+
+    def get_validator_subnet_nodes_info(
+        self, validator_id: int
+    ) -> list[SubnetNodeInfo]:
+        """
+        Get subnet node information for a specific validator.
+
+        Args:
+            validator_id: Validator ID
+
+        Returns:
+            List of SubnetNodeInfo objects with all fields decoded
+        """
+        try:
+            result = self.substrate.rpc_request(
+                method="network_getValidatorSubnetNodesInfo", params=[validator_id]
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            result_data = result["result"]
+
+            from ...utils.blockchain.type_registry import decode_vec_subnet_node_info
+
+            decoded_list = decode_vec_subnet_node_info(result_data)
+
+            if not decoded_list:
+                return []
+
+            def to_bytes(val):
+                """Convert decoded value to bytes for peer IDs and byte fields."""
+                if isinstance(val, bytes):
+                    return val
+                if isinstance(val, list):
+                    try:
+                        return bytes(val)
+                    except (ValueError, TypeError):
+                        return bytes(int(b) for b in val if 0 <= int(b) <= 255)
+                if isinstance(val, str):
+                    return val.encode("utf-8")
+                return b""
+
+            def to_address(val):
+                from ...utils.blockchain.formatting import to_checksum_address
+
+                if isinstance(val, str):
+                    raw_addr = val if val.startswith("0x") else "0x" + val
+                else:
+                    raw_addr = "0x" + (
+                        bytes(val).hex() if isinstance(val, (list, bytes)) else ""
+                    )
+                return to_checksum_address(raw_addr)
+
+            nodes = []
+            for decoded in decoded_list:
+                try:
+                    classification_data = decoded.get("classification", {})
+
+                    node_info = SubnetNodeInfo(
+                        subnet_id=decoded["subnet_id"],
+                        subnet_node_id=decoded["subnet_node_id"],
+                        coldkey=to_address(decoded["coldkey"]),
+                        hotkey=to_address(decoded["hotkey"]),
+                        peer_id=to_bytes(decoded["peer_id"]),
+                        bootnode_peer_id=to_bytes(decoded["bootnode_peer_id"]),
+                        client_peer_id=to_bytes(decoded["client_peer_id"]),
+                        bootnode=(
+                            to_bytes(decoded.get("bootnode"))
+                            if decoded.get("bootnode")
+                            else None
+                        ),
+                        identity=decoded.get("identity"),
+                        classification=classification_data,
+                        delegate_reward_rate=decoded.get("delegate_reward_rate", 0),
+                        last_delegate_reward_rate_update=decoded.get(
+                            "last_delegate_reward_rate_update", 0
+                        ),
+                        unique=(
+                            to_bytes(decoded.get("unique"))
+                            if decoded.get("unique")
+                            else None
+                        ),
+                        non_unique=(
+                            to_bytes(decoded.get("non_unique"))
+                            if decoded.get("non_unique")
+                            else None
+                        ),
+                        stake_balance=decoded.get("stake_balance", 0),
+                        node_delegate_stake_balance=decoded.get(
+                            "node_delegate_stake_balance", 0
+                        ),
+                        total_node_delegate_stake_shares=decoded.get(
+                            "total_node_delegate_stake_shares", 0
+                        ),
+                        coldkey_reputation=decoded.get("coldkey_reputation"),
+                        subnet_node_reputation=decoded.get("subnet_node_reputation", 0),
+                        node_slot_index=decoded.get("node_slot_index"),
+                        consecutive_idle_epochs=decoded.get(
+                            "consecutive_idle_epochs", 0
+                        ),
+                        consecutive_included_epochs=decoded.get(
+                            "consecutive_included_epochs", 0
+                        ),
+                    )
+                    nodes.append(node_info)
+                except Exception as e:
+                    logger.warning(
+                        "Failed to convert validator node info "
+                        f"(validator_id={validator_id}, "
+                        f"subnet_id={decoded.get('subnet_id')}, "
+                        f"node_id={decoded.get('subnet_node_id')}): {e}"
+                    )
+                    continue
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error getting validator subnet nodes info: {e}")
+            import traceback
+
+            logger.debug(traceback.format_exc())
+            return []
+
+    def get_coldkey_subnet_nodes_info(self, coldkey: str) -> list[SubnetNodeInfo]:
+        """
+        Get subnet node information for a specific coldkey using custom RPC method with full SCALE decoding.
+
+        Args:
+            coldkey: The coldkey account ID (0x... format)
+
+        Returns:
+            List of SubnetNodeInfo objects with all fields decoded
+
+        Reference:
+            - mesh-template chain_functions.py lines 1676-1688, 2160-2177
+            - hypertensor-evm/pallets/network/rpc/src/lib.rs lines 44-49
+        """
+        try:
+            # Normalize address format for RPC call (same as wallet.py)
+            if coldkey.startswith("0x"):
+                # EVM address format - use hex string without 0x prefix, normalize to lowercase
+                coldkey_param = coldkey[2:].lower()
+            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
+
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getColdkeySubnetNodesInfo", params=[coldkey_param]
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            result_data = result["result"]
+
+            # Decode Vec<SubnetNodeInfo> using custom type registry
+            from ...utils.blockchain.type_registry import decode_vec_subnet_node_info
+
+            decoded_list = decode_vec_subnet_node_info(result_data)
+
+            if not decoded_list:
+                return []
+            for idx, decoded in enumerate(decoded_list):
+                logger.info(
+                    f"  Node {idx}: subnet_id={decoded.get('subnet_id')}, node_id={decoded.get('subnet_node_id')}, coldkey={decoded.get('coldkey')}, hotkey={decoded.get('hotkey')}"
+                )
+
+            # Convert to list of SubnetNodeInfo objects (same logic as get_subnet_nodes_info)
+            def to_bytes(val):
+                """Convert decoded value to bytes for peer IDs and other byte fields."""
+                if isinstance(val, bytes):
+                    return val
+                if isinstance(val, list):
+                    # Vec<u8> from SCALE decoding is a list of integers (0-255)
+                    # Convert to bytes
+                    try:
+                        return bytes(val)
+                    except (ValueError, TypeError):
+                        # If conversion fails, try to convert each element
+                        return bytes(int(b) for b in val if 0 <= int(b) <= 255)
+                if isinstance(val, str):
+                    # String peer IDs should be encoded to UTF-8 bytes
+                    return val.encode("utf-8")
+                # Default: return empty bytes
+                return b""
+
+            def to_address(val):
+                from ...utils.blockchain.formatting import to_checksum_address
+
+                if isinstance(val, str):
+                    raw_addr = val if val.startswith("0x") else "0x" + val
+                else:
+                    raw_addr = "0x" + (
+                        bytes(val).hex() if isinstance(val, (list, bytes)) else ""
+                    )
+                return to_checksum_address(raw_addr)
+
+            nodes = []
+            for decoded in decoded_list:
+                try:
+                    classification_data = decoded.get("classification", {})
+
+                    # Log each node being processed
+                    node_subnet_id = decoded.get("subnet_id")
+                    node_id = decoded.get("subnet_node_id")
+                    node_coldkey = to_address(decoded["coldkey"])
+                    logger.debug(
+                        f"Processing node {node_id} in subnet {node_subnet_id}, coldkey: {node_coldkey}"
+                    )
+
+                    node_info = SubnetNodeInfo(
+                        subnet_id=node_subnet_id,
+                        subnet_node_id=node_id,
+                        coldkey=node_coldkey,
+                        hotkey=to_address(decoded["hotkey"]),
+                        peer_id=to_bytes(decoded["peer_id"]),
+                        bootnode_peer_id=to_bytes(decoded["bootnode_peer_id"]),
+                        client_peer_id=to_bytes(decoded["client_peer_id"]),
+                        bootnode=(
+                            to_bytes(decoded.get("bootnode"))
+                            if decoded.get("bootnode")
+                            else None
+                        ),
+                        identity=decoded.get("identity"),
+                        classification=classification_data,  # Pass dict as-is
+                        delegate_reward_rate=decoded.get("delegate_reward_rate", 0),
+                        last_delegate_reward_rate_update=decoded.get(
+                            "last_delegate_reward_rate_update", 0
+                        ),
+                        unique=(
+                            to_bytes(decoded.get("unique"))
+                            if decoded.get("unique")
+                            else None
+                        ),
+                        non_unique=(
+                            to_bytes(decoded.get("non_unique"))
+                            if decoded.get("non_unique")
+                            else None
+                        ),
+                        stake_balance=decoded.get("stake_balance", 0),
+                        node_delegate_stake_balance=decoded.get(
+                            "node_delegate_stake_balance", 0
+                        ),
+                        total_node_delegate_stake_shares=decoded.get(
+                            "total_node_delegate_stake_shares", 0
+                        ),
+                        coldkey_reputation=decoded.get("coldkey_reputation"),
+                        subnet_node_reputation=decoded.get("subnet_node_reputation", 0),
+                        node_slot_index=decoded.get("node_slot_index"),
+                        consecutive_idle_epochs=decoded.get(
+                            "consecutive_idle_epochs", 0
+                        ),
+                        consecutive_included_epochs=decoded.get(
+                            "consecutive_included_epochs", 0
+                        ),
+                    )
+                    nodes.append(node_info)
+                    logger.debug(f"Successfully added node {node_id} to list")
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to convert node info (subnet_id={decoded.get('subnet_id')}, node_id={decoded.get('subnet_node_id')}): {e}"
+                    )
+                    import traceback
+
+                    logger.debug(traceback.format_exc())
+                    continue
+
+            logger.info(
+                f"🔍 DEBUG: Successfully converted {len(nodes)} nodes for coldkey {coldkey}"
+            )
+            for node in nodes:
+                logger.info(
+                    f"  Final node: subnet_id={node.subnet_id}, node_id={node.subnet_node_id}, coldkey={node.coldkey}"
+                )
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error getting coldkey subnet nodes info: {e}")
+            import traceback
+
+            logger.debug(traceback.format_exc())
+            return []