htcli 1.1.0__py3-none-any.whl

src/htcli/client/rpc/subnet.py

@@ -0,0 +1,2104 @@
+"""
+RPC client for subnet-related queries using scalecodec for decoding.
+"""
+
+from typing import Any, Optional
+
+from substrateinterface import SubstrateInterface
+
+from ...models.enums.enum_types import KeyType, SubnetState
+from ...models.responses import SubnetData, SubnetInfo, SubnetNodeInfo
+
+from ...utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class SubnetRpcClient:
+    """RPC client for subnet-related queries."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the subnet RPC client."""
+        self.substrate = substrate
+
+    @staticmethod
+    def _to_bytes(value) -> bytes:
+        """Convert scalecodec values into raw bytes."""
+        if value is None:
+            return b""
+        if isinstance(value, bytes):
+            return value
+        if isinstance(value, str):
+            return value.encode("utf-8")
+        if isinstance(value, (list, tuple)):
+            return bytes(value)
+        return bytes(str(value), "utf-8")
+
+    @staticmethod
+    def _to_address(value) -> Optional[str]:
+        """Convert SCALE AccountId representations to checksummed hex strings.
+
+        Handles Option<AccountId> types - if value is a dict with 'Some' key,
+        extracts the inner value. Also handles empty lists/bytes as None.
+        
+        Returns EIP-55 checksummed addresses for proper display.
+        """
+        from ...utils.blockchain.formatting import to_checksum_address
+        
+        if value is None:
+            return None
+
+        # Handle Option<AccountId> - scalecodec might decode as dict with 'Some'/'None' keys
+        if isinstance(value, dict):
+            if "Some" in value:
+                value = value["Some"]
+            elif "None" in value or value == {}:
+                return None
+
+        # Handle empty collections as None
+        if isinstance(value, (list, tuple)) and len(value) == 0:
+            return None
+        if isinstance(value, bytes) and len(value) == 0:
+            return None
+
+        # Handle string representation
+        if isinstance(value, str):
+            # Check if it's an empty string or "None"
+            if not value or value.lower() == "none":
+                return None
+            raw_addr = value if value.startswith("0x") else f"0x{value}"
+            return to_checksum_address(raw_addr)
+
+        # Handle bytes/bytearray
+        if isinstance(value, (bytes, bytearray)):
+            # Check for zero address (all zeros)
+            if all(b == 0 for b in value):
+                return None
+            raw_addr = "0x" + value.hex()
+            return to_checksum_address(raw_addr)
+
+        # Handle list/tuple of bytes/ints
+        if isinstance(value, (list, tuple)):
+            # Check for empty or all-zero list
+            if len(value) == 0:
+                return None
+            if all(v == 0 for v in value):
+                return None
+            data = bytes(value)
+            raw_addr = "0x" + data.hex()
+            return to_checksum_address(raw_addr)
+
+        return str(value)
+
+
+    @staticmethod
+    def _decode_initial_coldkeys(raw) -> Optional[dict[str, int]]:
+        if not raw:
+            return None
+        mapping: dict[str, int] = {}
+        for entry in raw:
+            if not isinstance(entry, (list, tuple)) or len(entry) != 2:
+                continue
+            addr = SubnetRpcClient._to_address(entry[0])
+            max_regs = entry[1]
+            if addr:
+                mapping[addr] = max_regs
+        return mapping or None
+
+    @staticmethod
+    def _decode_key_types(raw) -> set:
+        """Decode BTreeSet<KeyType> from raw decoded data.
+
+        Handles multiple formats:
+        - List of integers: [0, 1, 2, 3] (RSA=0, ED25519=1, SECP256K1=2, ECDSA=3)
+        - List of strings: ["RSA", "ECDSA", "ED25519", "SECP256K1"]
+        - List of dicts: [{"type": "RSA"}, ...]
+        - Already decoded KeyType enums
+
+        Note: scalecodec decodes BTreeSet as list, so we convert list to set.
+        """
+        if raw is None:
+            return set()
+
+        key_types = set()
+
+        # Handle empty collections (ValueQuery returns [] for empty sets)
+        if isinstance(raw, (list, tuple)) and len(raw) == 0:
+            return set()
+        if isinstance(raw, set) and len(raw) == 0:
+            return set()
+
+        # Handle if already a set - convert to list for processing
+        if isinstance(raw, set):
+            raw = list(raw)
+
+        # Process list/tuple
+        if isinstance(raw, (list, tuple)):
+            for item in raw:
+                decoded = None
+
+                # Strategy 1: Already a KeyType enum
+                if isinstance(item, KeyType):
+                    decoded = item
+
+                # Strategy 2: Integer value (0=RSA, 1=ED25519, 2=SECP256K1, 3=ECDSA)
+                elif isinstance(item, int):
+                    try:
+                        decoded = KeyType(item)
+                    except (ValueError, KeyError):
+                        logger.debug(f"Invalid KeyType integer value: {item}")
+                        continue
+
+                # Strategy 3: String name (case-insensitive)
+                elif isinstance(item, str):
+                    item_upper = item.upper()
+                    # Handle Rust naming (lowercase) and Python naming (uppercase)
+                    # Map common variations to KeyType enum
+                    name_mapping = {
+                        "RSA": KeyType.RSA,
+                        "ED25519": KeyType.ED25519,
+                        "SECP256K1": KeyType.SECP256K1,
+                        "ECDSA": KeyType.ECDSA,
+                    }
+                    if item_upper in name_mapping:
+                        decoded = name_mapping[item_upper]
+                    else:
+                        try:
+                            # Try direct enum lookup
+                            decoded = KeyType[item_upper]
+                        except (KeyError, AttributeError):
+                            try:
+                                # Try as integer string
+                                decoded = KeyType(int(item))
+                            except (ValueError, KeyError):
+                                logger.debug(f"Invalid KeyType string: {item}")
+                                continue
+
+                # Strategy 4: Dict with "type" or "name" key
+                elif isinstance(item, dict):
+                    type_name = item.get("type") or item.get("name")
+                    if type_name:
+                        try:
+                            decoded = KeyType[type_name.upper()]
+                        except (KeyError, AttributeError):
+                            try:
+                                decoded = KeyType(int(type_name))
+                            except (ValueError, KeyError):
+                                logger.debug(f"Invalid KeyType dict value: {type_name}")
+                                continue
+
+                # Strategy 5: Object with .name or .value attribute
+                elif hasattr(item, "name"):
+                    try:
+                        decoded = KeyType[item.name.upper()]
+                    except (KeyError, AttributeError):
+                        try:
+                            decoded = KeyType(item.name)
+                        except (ValueError, KeyError):
+                            logger.debug(f"Invalid KeyType object name: {item.name}")
+                            continue
+                elif hasattr(item, "value"):
+                    try:
+                        decoded = KeyType(item.value)
+                    except (ValueError, KeyError):
+                        logger.debug(f"Invalid KeyType object value: {item.value}")
+                        continue
+
+                if decoded is not None:
+                    key_types.add(decoded)
+
+        return key_types
+
+    @staticmethod
+    def _decode_bootnode_access(raw) -> set[str]:
+        """Decode BTreeSet<AccountId> from raw decoded data.
+
+        AccountId is 20 bytes, needs to be converted to hex string (0x...).
+
+        Handles multiple formats:
+        - List of byte arrays: [[20 bytes], [20 bytes], ...]
+        - List of integers: [list of 20 integers]
+        - Already decoded addresses
+
+        Note: scalecodec decodes BTreeSet as list, so we convert list to set.
+        """
+        if raw is None:
+            return set()
+
+        result = set()
+
+        # Handle empty collections (ValueQuery returns [] for empty sets)
+        if isinstance(raw, (list, tuple)) and len(raw) == 0:
+            return set()
+        if isinstance(raw, set) and len(raw) == 0:
+            return set()
+
+        # Handle if already a set - convert to list for processing
+        if isinstance(raw, set):
+            raw = list(raw)
+
+        # Process list/tuple
+        if isinstance(raw, (list, tuple)):
+            for item in raw:
+                # Convert AccountId to address string
+                addr = SubnetRpcClient._to_address(item)
+                # Only add valid non-zero addresses
+                if addr and addr != "0x0000000000000000000000000000000000000000":
+                    result.add(addr)
+
+        return result
+
+    @staticmethod
+    def _decode_bootnodes(raw) -> set[bytes]:
+        """Decode BTreeSet<BoundedVec<u8>> from raw decoded data.
+
+        Note: scalecodec decodes BTreeSet as list, so we convert list to set.
+        """
+        if raw is None:
+            return set()
+
+        # Handle if it's already a set
+        if isinstance(raw, set):
+            return {SubnetRpcClient._to_bytes(item) for item in raw}
+
+        # Handle list/tuple (scalecodec decodes BTreeSet as list)
+        if isinstance(raw, (list, tuple)):
+            return {SubnetRpcClient._to_bytes(item) for item in raw}
+
+        return set()
+
+    def _query_subnet_storage_items(self, subnet_id: int) -> dict[str, Any]:
+        """Query all storage items for a subnet and return as a dict.
+        
+        This queries all 44+ storage items that compose SubnetInfo.
+        
+        Args:
+            subnet_id: The subnet ID to query
+            
+        Returns:
+            Dict mapping field names to storage values
+        """
+        if not self.substrate:
+            return {}
+        
+        storage_data = {}
+        
+        try:
+            # Main SubnetData
+            subnet_data_result = self.substrate.query(
+                module="Network",
+                storage_function="SubnetsData",
+                params=[subnet_id],
+            )
+            if subnet_data_result and subnet_data_result.value:
+                storage_data['subnet_data'] = subnet_data_result.value
+            
+            # All other storage items - map storage function name to field name
+            storage_items = [
+                ("SubnetIdFriendlyUid", "friendly_id", [subnet_id]),
+                ("ChurnLimit", "churn_limit", [subnet_id]),
+                ("ChurnLimitMultiplier", "churn_limit_multiplier", [subnet_id]),
+                ("SubnetMinStakeBalance", "min_stake", [subnet_id]),
+                ("SubnetMaxStakeBalance", "max_stake", [subnet_id]),
+                ("QueueImmunityEpochs", "queue_immunity_epochs", [subnet_id]),
+                ("TargetNodeRegistrationsPerEpoch", "target_node_registrations_per_epoch", [subnet_id]),
+                ("NodeRegistrationsThisEpoch", "node_registrations_this_epoch", [subnet_id]),
+                ("SubnetNodeQueueEpochs", "subnet_node_queue_epochs", [subnet_id]),
+                ("IdleClassificationEpochs", "idle_classification_epochs", [subnet_id]),
+                ("IncludedClassificationEpochs", "included_classification_epochs", [subnet_id]),
+                ("SubnetDelegateStakeRewardsPercentage", "delegate_stake_percentage", [subnet_id]),
+                ("LastSubnetDelegateStakeRewardsUpdate", "last_delegate_stake_rewards_update", [subnet_id]),
+                ("NodeBurnRateAlpha", "node_burn_rate_alpha", [subnet_id]),
+                ("CurrentNodeBurnRate", "current_node_burn_rate", [subnet_id]),
+                ("SubnetRegistrationInitialColdkeys", "initial_coldkeys", [subnet_id]),
+                ("InitialColdkeyData", "initial_coldkey_data", [subnet_id]),
+                ("MaxRegisteredNodes", "max_registered_nodes", [subnet_id]),
+                ("SubnetOwner", "owner", [subnet_id]),
+                ("PendingSubnetOwner", "pending_owner", [subnet_id]),
+                ("SubnetRegistrationEpoch", "registration_epoch", [subnet_id]),
+                ("PreviousSubnetPauseEpoch", "prev_pause_epoch", [subnet_id]),
+                ("SubnetKeyTypes", "key_types", [subnet_id]),
+                ("SubnetSlot", "slot_index", [subnet_id]),
+                ("SlotAssignment", "slot_assignment", [subnet_id]),
+                ("SubnetNodeMinWeightDecreaseReputationThreshold", "subnet_node_min_weight_decrease_reputation_threshold", [subnet_id]),
+                ("SubnetReputation", "reputation", [subnet_id]),
+                ("MinSubnetNodeReputation", "min_subnet_node_reputation", [subnet_id]),
+                ("AbsentDecreaseReputationFactor", "absent_decrease_reputation_factor", [subnet_id]),
+                ("IncludedIncreaseReputationFactor", "included_increase_reputation_factor", [subnet_id]),
+                ("BelowMinWeightDecreaseReputationFactor", "below_min_weight_decrease_reputation_factor", [subnet_id]),
+                ("NonAttestorDecreaseReputationFactor", "non_attestor_decrease_reputation_factor", [subnet_id]),
+                ("NonConsensusAttestorDecreaseReputationFactor", "non_consensus_attestor_decrease_reputation_factor", [subnet_id]),
+                ("ValidatorAbsentSubnetNodeReputationFactor", "validator_absent_subnet_node_reputation_factor", [subnet_id]),
+                ("ValidatorNonConsensusSubnetNodeReputationFactor", "validator_non_consensus_subnet_node_reputation_factor", [subnet_id]),
+                ("SubnetBootnodeAccess", "bootnode_access", [subnet_id]),
+                ("SubnetBootnodes", "bootnodes", [subnet_id]),
+                ("TotalSubnetNodes", "total_nodes", [subnet_id]),
+                ("TotalActiveSubnetNodes", "total_active_nodes", [subnet_id]),
+                ("TotalSubnetElectableNodes", "total_electable_nodes", [subnet_id]),
+                ("TotalSubnetStake", "total_subnet_stake", [subnet_id]),
+                ("TotalSubnetDelegateStakeShares", "total_subnet_delegate_stake_shares", [subnet_id]),
+                ("TotalSubnetDelegateStakeBalance", "total_subnet_delegate_stake_balance", [subnet_id]),
+            ]
+            
+            for storage_name, field_name, params in storage_items:
+                try:
+                    result = self.substrate.query(
+                        module="Network",
+                        storage_function=storage_name,
+                        params=params,
+                    )
+                    if result and result.value is not None:
+                        storage_data[field_name] = result.value
+                except Exception as e:
+                    logger.debug(f"Failed to query {storage_name} for subnet {subnet_id}: {e}")
+                    # Continue with other queries
+                    
+        except Exception as e:
+            logger.error(f"Error querying storage for subnet {subnet_id}: {e}")
+        
+        return storage_data
+
+    def _get_min_subnet_delegate_stake_balance(self, subnet_id: int) -> int:
+        """Get minimum subnet delegate stake balance.
+        
+        This implements the logic from info.rs line 83.
+        Requires querying additional storage items to compute the value.
+        
+        Args:
+            subnet_id: The subnet ID
+            
+        Returns:
+            Minimum delegate stake balance
+        """
+        if not self.substrate:
+            return 0
+        
+        try:
+            # Query TotalSubnetDelegateStakeShares and TotalSubnetDelegateStakeBalance
+            shares_result = self.substrate.query(
+                module="Network",
+                storage_function="TotalSubnetDelegateStakeShares",
+                params=[subnet_id],
+            )
+            balance_result = self.substrate.query(
+                module="Network",
+                storage_function="TotalSubnetDelegateStakeBalance",
+                params=[subnet_id],
+            )
+            
+            shares = shares_result.value if shares_result and shares_result.value else 0
+            balance = balance_result.value if balance_result and balance_result.value else 0
+            
+            # Compute minimum: if shares > 0, return balance / shares, else 0
+            if shares > 0:
+                return balance // shares
+            return 0
+        except Exception as e:
+            logger.debug(f"Error computing min delegate stake for subnet {subnet_id}: {e}")
+            return 0
+
+    def _build_subnet_info_from_storage(self, subnet_id: int, storage_data: dict[str, Any]) -> Optional[SubnetInfo]:
+        """Build SubnetInfo object from storage data.
+        
+        Args:
+            subnet_id: The subnet ID
+            storage_data: Dict of storage field names to values
+            
+        Returns:
+            SubnetInfo object or None if subnet_data is missing
+        """
+        subnet_data = storage_data.get('subnet_data')
+        if not subnet_data:
+            return None
+        
+        # Extract values from subnet_data
+        decoded = {
+            "id": subnet_data.get("id", subnet_id),
+            "friendly_id": storage_data.get("friendly_id"),
+            "name": subnet_data.get("name", b""),
+            "repo": subnet_data.get("repo", b""),
+            "description": subnet_data.get("description", b""),
+            "misc": subnet_data.get("misc", b""),
+            "state": subnet_data.get("state"),  # Will be decoded by _build_subnet_info
+            "start_epoch": subnet_data.get("start_epoch", 0),
+            "churn_limit": storage_data.get("churn_limit", 0),
+            "churn_limit_multiplier": storage_data.get("churn_limit_multiplier", 1),
+            "min_stake": storage_data.get("min_stake", 0),
+            "max_stake": storage_data.get("max_stake", 0),
+            "queue_immunity_epochs": storage_data.get("queue_immunity_epochs", 0),
+            "target_node_registrations_per_epoch": storage_data.get("target_node_registrations_per_epoch", 0),
+            "node_registrations_this_epoch": storage_data.get("node_registrations_this_epoch", 0),
+            "subnet_node_queue_epochs": storage_data.get("subnet_node_queue_epochs", 0),
+            "idle_classification_epochs": storage_data.get("idle_classification_epochs", 0),
+            "included_classification_epochs": storage_data.get("included_classification_epochs", 0),
+            "delegate_stake_percentage": storage_data.get("delegate_stake_percentage", 0),
+            "last_delegate_stake_rewards_update": storage_data.get("last_delegate_stake_rewards_update", 0),
+            "node_burn_rate_alpha": storage_data.get("node_burn_rate_alpha", 0),
+            "current_node_burn_rate": storage_data.get("current_node_burn_rate", 0),
+            "initial_coldkeys": storage_data.get("initial_coldkeys"),
+            "initial_coldkey_data": storage_data.get("initial_coldkey_data"),
+            "max_registered_nodes": storage_data.get("max_registered_nodes", 0),
+            "owner": storage_data.get("owner"),
+            "pending_owner": storage_data.get("pending_owner"),
+            "registration_epoch": storage_data.get("registration_epoch"),
+            "prev_pause_epoch": storage_data.get("prev_pause_epoch", 0),
+            "key_types": storage_data.get("key_types"),
+            "slot_index": storage_data.get("slot_index"),
+            "slot_assignment": storage_data.get("slot_assignment"),
+            "subnet_node_min_weight_decrease_reputation_threshold": storage_data.get("subnet_node_min_weight_decrease_reputation_threshold", 0),
+            "reputation": storage_data.get("reputation", 0),
+            "min_subnet_node_reputation": storage_data.get("min_subnet_node_reputation", 0),
+            "absent_decrease_reputation_factor": storage_data.get("absent_decrease_reputation_factor", 0),
+            "included_increase_reputation_factor": storage_data.get("included_increase_reputation_factor", 0),
+            "below_min_weight_decrease_reputation_factor": storage_data.get("below_min_weight_decrease_reputation_factor", 0),
+            "non_attestor_decrease_reputation_factor": storage_data.get("non_attestor_decrease_reputation_factor", 0),
+            "non_consensus_attestor_decrease_reputation_factor": storage_data.get("non_consensus_attestor_decrease_reputation_factor", 0),
+            "validator_absent_subnet_node_reputation_factor": storage_data.get("validator_absent_subnet_node_reputation_factor", 0),
+            "validator_non_consensus_subnet_node_reputation_factor": storage_data.get("validator_non_consensus_subnet_node_reputation_factor", 0),
+            "bootnode_access": storage_data.get("bootnode_access"),
+            "bootnodes": storage_data.get("bootnodes"),
+            "total_nodes": storage_data.get("total_nodes", 0),
+            "total_active_nodes": storage_data.get("total_active_nodes", 0),
+            "total_electable_nodes": storage_data.get("total_electable_nodes", 0),
+            "current_min_delegate_stake": self._get_min_subnet_delegate_stake_balance(subnet_id),
+            "total_subnet_stake": storage_data.get("total_subnet_stake", 0),
+            "total_subnet_delegate_stake_shares": storage_data.get("total_subnet_delegate_stake_shares", 0),
+            "total_subnet_delegate_stake_balance": storage_data.get("total_subnet_delegate_stake_balance", 0),
+        }
+        
+        # Build SubnetInfo using existing _build_subnet_info method
+        return self._build_subnet_info(decoded)
+
+    def _get_subnet_info_from_storage(self, subnet_id: int) -> Optional[SubnetInfo]:
+        """Get SubnetInfo by querying storage directly.
+        
+        This replaces the RPC-based approach with storage queries.
+        
+        Args:
+            subnet_id: The subnet ID
+            
+        Returns:
+            SubnetInfo object or None if subnet not found
+        """
+        if not self.substrate:
+            logger.error("Cannot get subnet info from storage: not connected to blockchain")
+            return None
+        
+        try:
+            # Query all storage items
+            storage_data = self._query_subnet_storage_items(subnet_id)
+            
+            # Build SubnetInfo from storage data
+            subnet_info = self._build_subnet_info_from_storage(subnet_id, storage_data)
+            
+            return subnet_info
+            
+        except Exception as e:
+            logger.error(f"Error getting subnet info from storage for {subnet_id}: {e}")
+            return None
+
+    def _query_storage_for_missing_fields(
+        self, subnet_id: int, subnet_info: SubnetInfo
+    ) -> SubnetInfo:
+        """Query storage for missing fields that RPC might not return correctly.
+
+        This queries storage directly for:
+        - owner (SubnetOwner)
+        - pending_owner (PendingSubnetOwner)
+        - key_types (SubnetKeyTypes)
+        - bootnodes (SubnetBootnodes)
+        - bootnode_access (SubnetBootnodeAccess)
+        - initial_coldkeys (SubnetRegistrationInitialColdkeys)
+        - registration_epoch (SubnetRegistrationEpoch)
+        - slot_index (SubnetSlot)
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_info: The SubnetInfo object to update
+
+        Returns:
+            Updated SubnetInfo with storage-queried fields
+        """
+        if not self.substrate:
+            return subnet_info
+
+        try:
+            # Query owner if missing
+            if not subnet_info.owner:
+                try:
+                    owner_result = self.substrate.query(
+                        module="Network",
+                        storage_function="SubnetOwner",
+                        params=[subnet_id],
+                    )
+                    if owner_result and owner_result.value is not None:
+                        owner_address = self._to_address(owner_result.value)
+                        if (
+                            owner_address
+                            and owner_address
+                            != "0x0000000000000000000000000000000000000000"
+                        ):
+                            subnet_info.owner = owner_address
+                except Exception as e:
+                    logger.debug(
+                        f"Failed to query SubnetOwner storage for subnet {subnet_id}: {e}"
+                    )
+
+            # Always query pending_owner from storage (RPC might not return it correctly)
+            # OptionQuery returns None if not set
+            try:
+                pending_owner_result = self.substrate.query(
+                    module="Network",
+                    storage_function="PendingSubnetOwner",
+                    params=[subnet_id],
+                )
+                if pending_owner_result and pending_owner_result.value is not None:
+                    pending_owner_address = self._to_address(
+                        pending_owner_result.value
+                    )
+                    if (
+                        pending_owner_address
+                        and pending_owner_address
+                        != "0x0000000000000000000000000000000000000000"
+                    ):
+                        subnet_info.pending_owner = pending_owner_address
+                    else:
+                        # Explicitly set to None if zero address
+                        subnet_info.pending_owner = None
+                else:
+                    # No pending owner in storage
+                    subnet_info.pending_owner = None
+            except Exception as e:
+                logger.debug(
+                    f"Failed to query PendingSubnetOwner storage for subnet {subnet_id}: {e}"
+                )
+
+            # Always query key_types from storage (RPC might not return it correctly)
+            # ValueQuery returns [] (empty list) if not set, not None
+            try:
+                key_types_result = self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetKeyTypes",
+                    params=[subnet_id],
+                )
+                if key_types_result and hasattr(key_types_result, "value"):
+                    raw_value = key_types_result.value
+                    # ValueQuery always returns a value (empty list [] if not set)
+                    decoded_key_types = self._decode_key_types(raw_value)
+                    # Always update, even if empty set (to ensure we have the latest from storage)
+                    subnet_info.key_types = decoded_key_types
+                    logger.debug(
+                        f"Subnet {subnet_id} key_types from storage: {decoded_key_types}"
+                    )
+                else:
+                    # No result - set empty set
+                    subnet_info.key_types = set()
+            except Exception as e:
+                logger.warning(
+                    f"Failed to query SubnetKeyTypes storage for subnet {subnet_id}: {e}"
+                )
+                # Set empty set on error to ensure field is initialized
+                subnet_info.key_types = set()
+
+            # Always query bootnodes from storage (RPC might not return it correctly)
+            # ValueQuery returns [] (empty list) if not set, not None
+            try:
+                bootnodes_result = self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetBootnodes",
+                    params=[subnet_id],
+                )
+                if bootnodes_result and hasattr(bootnodes_result, "value"):
+                    raw_value = bootnodes_result.value
+                    # ValueQuery always returns a value (empty list [] if not set)
+                    decoded_bootnodes = self._decode_bootnodes(raw_value)
+                    # Always update, even if empty set (to ensure we have the latest from storage)
+                    subnet_info.bootnodes = decoded_bootnodes
+                    logger.debug(
+                        f"Subnet {subnet_id} bootnodes from storage: {len(decoded_bootnodes)} bootnodes"
+                    )
+                else:
+                    # No result - set empty set
+                    subnet_info.bootnodes = set()
+            except Exception as e:
+                logger.warning(
+                    f"Failed to query SubnetBootnodes storage for subnet {subnet_id}: {e}"
+                )
+                # Set empty set on error to ensure field is initialized
+                subnet_info.bootnodes = set()
+
+            # Always query bootnode_access from storage (RPC might not return it correctly)
+            # ValueQuery returns [] (empty list) if not set, not None
+            try:
+                bootnode_access_result = self.substrate.query(
+                    module="Network",
+                    storage_function="SubnetBootnodeAccess",
+                    params=[subnet_id],
+                )
+                if bootnode_access_result and hasattr(bootnode_access_result, "value"):
+                    raw_value = bootnode_access_result.value
+                    # ValueQuery always returns a value (empty list [] if not set)
+                    decoded_bootnode_access = self._decode_bootnode_access(raw_value)
+                    # Always update, even if empty set (to ensure we have the latest from storage)
+                    subnet_info.bootnode_access = decoded_bootnode_access
+                    logger.debug(
+                        f"Subnet {subnet_id} bootnode_access from storage: {len(decoded_bootnode_access)} addresses"
+                    )
+                else:
+                    # No result - set empty set
+                    subnet_info.bootnode_access = set()
+            except Exception as e:
+                logger.warning(
+                    f"Failed to query SubnetBootnodeAccess storage for subnet {subnet_id}: {e}"
+                )
+                # Set empty set on error to ensure field is initialized
+                subnet_info.bootnode_access = set()
+
+            # Query initial_coldkeys if missing
+            if not subnet_info.initial_coldkeys:
+                try:
+                    initial_coldkeys_result = self.substrate.query(
+                        module="Network",
+                        storage_function="SubnetRegistrationInitialColdkeys",
+                        params=[subnet_id],
+                    )
+                    if (
+                        initial_coldkeys_result
+                        and initial_coldkeys_result.value is not None
+                    ):
+                        raw_value = initial_coldkeys_result.value
+                        decoded_initial_coldkeys = self._decode_initial_coldkeys(
+                            raw_value
+                        )
+                        if decoded_initial_coldkeys:
+                            subnet_info.initial_coldkeys = decoded_initial_coldkeys
+                except Exception as e:
+                    logger.debug(
+                        f"Failed to query SubnetRegistrationInitialColdkeys storage for subnet {subnet_id}: {e}"
+                    )
+
+            # Query registration_epoch if missing
+            if subnet_info.registration_epoch is None:
+                try:
+                    registration_epoch_result = self.substrate.query(
+                        module="Network",
+                        storage_function="SubnetRegistrationEpoch",
+                        params=[subnet_id],
+                    )
+                    if (
+                        registration_epoch_result
+                        and registration_epoch_result.value is not None
+                    ):
+                        subnet_info.registration_epoch = registration_epoch_result.value
+                except Exception as e:
+                    logger.debug(
+                        f"Failed to query SubnetRegistrationEpoch storage for subnet {subnet_id}: {e}"
+                    )
+
+            # Query slot_index if missing
+            if subnet_info.slot_index is None:
+                try:
+                    slot_index_result = self.substrate.query(
+                        module="Network",
+                        storage_function="SubnetSlot",
+                        params=[subnet_id],
+                    )
+                    if slot_index_result and slot_index_result.value is not None:
+                        subnet_info.slot_index = slot_index_result.value
+                except Exception as e:
+                    logger.debug(
+                        f"Failed to query SubnetSlot storage for subnet {subnet_id}: {e}"
+                    )
+
+        except Exception as e:
+            logger.warning(
+                f"Error querying storage for missing fields for subnet {subnet_id}: {e}"
+            )
+
+        return subnet_info
+
+    @staticmethod
+    def _decode_state(value) -> SubnetState:
+        if value is None:
+            return SubnetState.Registered
+        if isinstance(value, SubnetState):
+            return value
+        if hasattr(value, "name"):
+            return SubnetState(value.name)
+        if isinstance(value, str):
+            try:
+                return SubnetState(value)
+            except ValueError:
+                return SubnetState[value]
+        if isinstance(value, dict) and value:
+            key = next(iter(value))
+            return SubnetState(key)
+        return SubnetState.Registered
+
+    @classmethod
+    def _build_subnet_info(cls, decoded: dict) -> SubnetInfo:
+        friendly_id = None
+        if "friendly_id" in decoded or "friendlyId" in decoded:
+            friendly_id = decoded.get("friendly_id", decoded.get("friendlyId"))
+        else:
+            friendly_id = decoded.get("id")
+
+        # Decode owner - handle Option<AccountId> properly
+        raw_owner = decoded.get("owner")
+        owner = cls._to_address(raw_owner)
+
+        # Decode pending_owner
+        raw_pending_owner = decoded.get("pending_owner")
+        pending_owner = cls._to_address(raw_pending_owner)
+
+        # Extract raw values for decoding
+        raw_key_types = decoded.get("key_types")
+        raw_bootnode_access = decoded.get("bootnode_access")
+        raw_bootnodes = decoded.get("bootnodes")
+
+        return SubnetInfo(
+            id=decoded["id"],
+            friendly_id=friendly_id,
+            name=cls._to_bytes(decoded.get("name")),
+            repo=cls._to_bytes(decoded.get("repo")),
+            description=cls._to_bytes(decoded.get("description")),
+            misc=cls._to_bytes(decoded.get("misc")),
+            state=cls._decode_state(decoded.get("state")),
+            start_epoch=decoded.get("start_epoch", 0),
+            churn_limit=decoded.get("churn_limit", 0),
+            churn_limit_multiplier=decoded.get("churn_limit_multiplier", 1),
+            min_stake=decoded.get("min_stake", 0),
+            max_stake=decoded.get("max_stake", 0),
+            queue_immunity_epochs=decoded.get("queue_immunity_epochs", 0),
+            target_node_registrations_per_epoch=decoded.get(
+                "target_node_registrations_per_epoch", 0
+            ),
+            node_registrations_this_epoch=decoded.get("node_registrations_this_epoch", 0),
+            subnet_node_queue_epochs=decoded.get("subnet_node_queue_epochs", 0),
+            idle_classification_epochs=decoded.get("idle_classification_epochs", 0),
+            included_classification_epochs=decoded.get(
+                "included_classification_epochs", 0
+            ),
+            delegate_stake_percentage=decoded.get("delegate_stake_percentage", 0),
+            last_delegate_stake_rewards_update=decoded.get("last_delegate_stake_rewards_update", 0),
+            node_burn_rate_alpha=decoded.get("node_burn_rate_alpha", 0),
+            current_node_burn_rate=decoded.get("current_node_burn_rate", 0),
+            initial_coldkeys=cls._decode_initial_coldkeys(
+                decoded.get("initial_coldkeys")
+            ),
+            initial_coldkey_data=cls._decode_initial_coldkeys(
+                decoded.get("initial_coldkey_data")
+            ),
+            max_registered_nodes=decoded.get("max_registered_nodes", 0),
+            owner=owner,
+            pending_owner=pending_owner,
+            registration_epoch=decoded.get("registration_epoch"),
+            prev_pause_epoch=decoded.get("prev_pause_epoch", 0),
+            key_types=cls._decode_key_types(raw_key_types),
+            slot_index=decoded.get("slot_index"),
+            slot_assignment=decoded.get("slot_assignment"),
+            subnet_node_min_weight_decrease_reputation_threshold=decoded.get(
+                "subnet_node_min_weight_decrease_reputation_threshold", 0
+            ),
+            reputation=decoded.get("reputation", 0),
+            min_subnet_node_reputation=decoded.get("min_subnet_node_reputation", 0),
+            absent_decrease_reputation_factor=decoded.get(
+                "absent_decrease_reputation_factor", 0
+            ),
+            included_increase_reputation_factor=decoded.get(
+                "included_increase_reputation_factor", 0
+            ),
+            below_min_weight_decrease_reputation_factor=decoded.get(
+                "below_min_weight_decrease_reputation_factor", 0
+            ),
+            non_attestor_decrease_reputation_factor=decoded.get(
+                "non_attestor_decrease_reputation_factor", 0
+            ),
+            non_consensus_attestor_decrease_reputation_factor=decoded.get(
+                "non_consensus_attestor_decrease_reputation_factor", 0
+            ),
+            validator_absent_subnet_node_reputation_factor=decoded.get(
+                "validator_absent_subnet_node_reputation_factor", 0
+            ),
+            validator_non_consensus_subnet_node_reputation_factor=decoded.get(
+                "validator_non_consensus_subnet_node_reputation_factor", 0
+            ),
+            bootnode_access=cls._decode_bootnode_access(raw_bootnode_access),
+            bootnodes=cls._decode_bootnodes(raw_bootnodes),
+            total_nodes=decoded.get("total_nodes", 0),
+            total_active_nodes=decoded.get("total_active_nodes", 0),
+            total_electable_nodes=decoded.get("total_electable_nodes", 0),
+            current_min_delegate_stake=decoded.get("current_min_delegate_stake", 0),
+            total_subnet_stake=decoded.get("total_subnet_stake", 0),
+            total_subnet_delegate_stake_shares=decoded.get("total_subnet_delegate_stake_shares", 0),
+            total_subnet_delegate_stake_balance=decoded.get("total_subnet_delegate_stake_balance", 0),
+        )
+
+    def get_subnet_info(self, subnet_id: int) -> Optional[SubnetInfo]:
+        """
+        Get complete subnet information via RPC, with storage fallback.
+        
+        This uses the network_getSubnetInfo RPC method which returns SubnetInfo
+        serialized as SCALE bytes. Falls back to storage queries if RPC fails.
+        """
+        if self.substrate is None:
+            logger.error("Cannot get subnet info: not connected to blockchain")
+            return None
+
+        try:
+            # Try RPC method first (most efficient)
+            logger.debug(f"Attempting network_getSubnetInfo RPC for subnet {subnet_id}")
+            result = self.substrate.rpc_request(
+                method="network_getSubnetInfo", params=[subnet_id]
+            )
+            
+            if result and result.get("result"):
+                from ...utils.blockchain.type_registry import decode_option_subnet_info
+                
+                result_data = result["result"]
+                # Handle different data formats
+                if isinstance(result_data, list):
+                    data_bytes = bytes(result_data)
+                elif isinstance(result_data, str):
+                    hex_data = result_data[2:] if result_data.startswith("0x") else result_data
+                    data_bytes = bytes.fromhex(hex_data)
+                else:
+                    data_bytes = result_data
+                
+                decoded = decode_option_subnet_info(data_bytes)
+                
+                if decoded:
+                    logger.info(f"Successfully decoded subnet {subnet_id} via RPC")
+                    subnet_info = self._build_subnet_info(decoded)
+                    # Query storage for any fields that might be missing from RPC
+                    subnet_info = self._query_storage_for_missing_fields(subnet_id, subnet_info)
+                    return subnet_info
+                else:
+                    logger.debug(f"Subnet {subnet_id} not found via RPC (Option::None)")
+                    return None
+                    
+        except Exception as e:
+            logger.debug(f"RPC method failed for subnet {subnet_id}, falling back to storage: {e}")
+
+        # Fallback: Use storage-based query
+        try:
+            logger.debug(f"Falling back to storage query for subnet {subnet_id}")
+            subnet_info = self._get_subnet_info_from_storage(subnet_id)
+            return subnet_info
+
+        except Exception as e:
+            logger.error(f"Error getting subnet info from storage for {subnet_id}: {e}")
+            return None
+
+    def get_all_subnets_info(self) -> list[SubnetInfo]:
+        """
+        Get information about all subnets by querying storage directly.
+
+        This method queries SubnetsData storage to find all existing subnets.
+        It handles gaps in subnet IDs (e.g., if subnet 1 is removed, we still find 2, 3, 4, 5).
+        
+        This method includes ALL subnets regardless of their state:
+        - Active subnets (state = Active)
+        - Inactive/Registered subnets (state = Registered)
+        - Paused subnets (state = Paused)
+        - Subnets whose status has changed (current state is read from storage)
+        
+        Only subnets that don't exist in SubnetsData storage are excluded.
+        
+        Strategy:
+        1. First tries RPC method network_getAllSubnetsInfo (most efficient, uses SubnetsData::iter())
+        2. Falls back to storage discovery method that scans SubnetsData to find all existing subnet IDs
+        """
+        if self.substrate is None:
+            logger.error("Cannot get subnets info: not connected to blockchain")
+            return []
+
+        try:
+            # First, try to use the RPC method if available (most efficient)
+            # This uses SubnetsData::iter() internally, which finds all existing subnets
+            try:
+                result = self.substrate.rpc_request(
+                    method="network_getAllSubnetsInfo", params=[]
+                )
+                if result and result.get("result"):
+                    logger.debug("Using RPC method network_getAllSubnetsInfo")
+                    return self._get_all_subnets_info_legacy_rpc()
+            except Exception as e:
+                logger.debug(f"RPC method not available, falling back to storage discovery: {e}")
+            
+            # Fallback: Use storage discovery method that scans SubnetsData storage
+            # This properly handles gaps (e.g., if subnet 1 was removed)
+            logger.debug("Using storage discovery method to find all subnet IDs")
+            return self._get_all_subnets_info_individual()
+
+        except Exception as e:
+            logger.error(f"Error getting all subnets info from storage: {e}")
+            return []
+
+    def _get_all_subnets_info_legacy_rpc(self) -> list[SubnetInfo]:
+        """
+        Legacy RPC-based method (kept for reference, not used).
+        
+        Get information about all subnets using the network_getAllSubnetsInfo RPC method.
+
+        This uses the proper RPC method that returns Vec<SubnetInfo>, which is more efficient
+        than querying subnets individually. Falls back to individual queries if Vec decoding fails.
+        """
+        if self.substrate is None:
+            logger.error("Cannot get subnets info: not connected to blockchain")
+            return []
+
+        try:
+            # Try using the proper RPC method first
+            logger.debug(
+                "Attempting to get all subnets via network_getAllSubnetsInfo RPC..."
+            )
+            result = self.substrate.rpc_request(
+                method="network_getAllSubnetsInfo", params=[]
+            )
+
+            if result and result.get("result"):
+                result_data = result["result"]
+
+                from ...utils.blockchain.type_registry import decode_vec_subnet_info
+
+                decoded_list = decode_vec_subnet_info(result_data)
+
+                logger.info(
+                    f"Decoded {len(decoded_list) if decoded_list else 0} subnets from RPC response"
+                )
+
+                if decoded_list:
+                    # Successfully decoded Vec<SubnetInfo> - convert to SubnetInfo models
+                    subnets: list[SubnetInfo] = []
+                    for decoded in decoded_list:
+                        subnet_id = decoded.get("id", "?")
+                        logger.debug(f"Processing decoded subnet ID: {subnet_id}")
+                        try:
+                            subnet_info = self._build_subnet_info(decoded)
+
+                            # Query storage for missing fields (owner, pending_owner, key_types, bootnodes, bootnode_access)
+                            subnet_id_val = decoded.get("id", subnet_id)
+                            subnet_info = self._query_storage_for_missing_fields(
+                                subnet_id_val, subnet_info
+                            )
+
+                            subnets.append(subnet_info)
+                        except ValueError as validation_error:
+                            # Validation error - log and try to fix or skip
+                            error_msg = str(validation_error)
+
+                            # If it's a node count validation issue, try to fix it
+                            if (
+                                "total_active_nodes" in error_msg
+                                or "total_electable_nodes" in error_msg
+                            ):
+                                logger.warning(
+                                    f"Subnet {subnet_id} has invalid node counts - attempting to fix: {error_msg}"
+                                )
+                                # Try to fix by ensuring node counts are logically consistent
+                                total_nodes = decoded.get("total_nodes", 0)
+                                total_active = decoded.get("total_active_nodes", 0)
+                                total_electable = decoded.get(
+                                    "total_electable_nodes", 0
+                                )
+
+                                # Clamp values to be valid
+                                if total_active > total_nodes:
+                                    logger.warning(
+                                        f"Subnet {subnet_id}: Fixing total_active_nodes ({total_active}) > total_nodes ({total_nodes})"
+                                    )
+                                    decoded["total_active_nodes"] = min(
+                                        total_active, total_nodes
+                                    )
+
+                                if total_electable > decoded.get(
+                                    "total_active_nodes", 0
+                                ):
+                                    logger.warning(
+                                        f"Subnet {subnet_id}: Fixing total_electable_nodes ({total_electable}) > total_active_nodes"
+                                    )
+                                    decoded["total_electable_nodes"] = min(
+                                        total_electable,
+                                        decoded.get("total_active_nodes", 0),
+                                    )
+
+                                # Try again with fixed values
+                                try:
+                                    subnet_info = self._build_subnet_info(decoded)
+                                    # Query storage for missing fields after fixing node counts
+                                    subnet_info = (
+                                        self._query_storage_for_missing_fields(
+                                            subnet_id, subnet_info
+                                        )
+                                    )
+                                    subnets.append(subnet_info)
+                                except Exception as retry_error:
+                                    logger.error(
+                                        f"Failed to convert subnet {subnet_id} even after fixing node counts: {retry_error}"
+                                    )
+                                    continue
+                            else:
+                                logger.error(
+                                    f"Failed to convert subnet {subnet_id}: {validation_error}. Skipping."
+                                )
+                                continue
+                        except Exception as conversion_error:
+                            logger.error(
+                                f"Failed to convert subnet {decoded.get('id', '?')}: {conversion_error}"
+                            )
+                            continue
+
+                    logger.info(
+                        f"Successfully retrieved {len(subnets)} subnet(s) via RPC Vec<SubnetInfo>"
+                    )
+                    return subnets
+                else:
+                    logger.warning(
+                        "RPC returned data but Vec decoding failed, falling back to individual queries"
+                    )
+            else:
+                logger.warning(
+                    "RPC method returned no result, falling back to individual queries"
+                )
+
+        except Exception as e:
+            logger.warning(
+                f"Error using network_getAllSubnetsInfo RPC: {e}, falling back to individual queries"
+            )
+
+        # Fallback: query subnets individually
+        logger.debug("Falling back to individual subnet queries...")
+        return self._get_all_subnets_info_individual()
+
+    def _get_all_subnets_info_individual(self) -> list[SubnetInfo]:
+        """
+        Fallback method: Get information about all subnets by discovering subnet IDs from storage
+        and then querying each individually using storage queries.
+
+        This method:
+        1. Queries TotalSubnetUids to get the maximum possible subnet ID
+        2. Scans SubnetsData storage to discover all actual subnet IDs (handles non-sequential IDs)
+        3. Queries each discovered subnet via storage queries
+
+        This handles cases where subnets don't start at ID 1.
+        """
+        try:
+            logger.debug("Discovering subnet IDs from storage...")
+
+            # Step 1: Get TotalSubnetUids to know the maximum possible subnet ID
+            total_subnets_result = self.substrate.query(
+                module="Network", storage_function="TotalSubnetUids"
+            )
+            total_subnet_uids = (
+                total_subnets_result.value if total_subnets_result else 0
+            )
+            logger.debug(f"TotalSubnetUids: {total_subnet_uids}")
+
+            # Step 2: Discover all actual subnet IDs by querying SubnetsData storage
+            # This handles non-sequential subnet IDs (e.g., if subnets start at ID 21)
+            subnet_ids = set()
+            max_subnet_id = max(
+                total_subnet_uids, 50
+            )  # Check at least up to TotalSubnetUids or 50
+
+            logger.debug(
+                f"Scanning SubnetsData storage from ID 1 to {max_subnet_id}..."
+            )
+            for test_id in range(1, max_subnet_id + 1):
+                try:
+                    result = self.substrate.query(
+                        module="Network",
+                        storage_function="SubnetsData",
+                        params=[test_id],
+                    )
+                    if result and result.value is not None:
+                        subnet_ids.add(test_id)
+                        logger.debug(f"Found subnet ID in storage: {test_id}")
+                except Exception:
+                    # Subnet doesn't exist, continue silently
+                    pass
+
+            # If we didn't find any, try a broader scan
+            if not subnet_ids:
+                logger.warning(
+                    "No subnets found in initial scan, trying broader range (1-200)..."
+                )
+                for test_id in range(1, 201):
+                    try:
+                        result = self.substrate.query(
+                            module="Network",
+                            storage_function="SubnetsData",
+                            params=[test_id],
+                        )
+                        if result and result.value is not None:
+                            subnet_ids.add(test_id)
+                            logger.debug(f"Found subnet ID in storage: {test_id}")
+                    except Exception:
+                        pass
+
+            if not subnet_ids:
+                logger.warning(
+                    "No subnets found in storage, cannot retrieve subnet info"
+                )
+                return []
+
+            logger.info(
+                f"Discovered {len(subnet_ids)} subnet ID(s) from storage: {sorted(subnet_ids)}"
+            )
+
+            # Step 3: Query each discovered subnet ID using storage queries
+            subnets: list[SubnetInfo] = []
+
+            for subnet_id in sorted(subnet_ids):
+                logger.debug(f"Querying subnet {subnet_id} via storage...")
+
+                # Query individual subnet using storage queries
+                try:
+                    subnet_info = self._get_subnet_info_from_storage(subnet_id)
+                    if subnet_info:
+                        subnets.append(subnet_info)
+                        logger.debug(f"Successfully retrieved subnet {subnet_id}")
+                    else:
+                        logger.warning(f"No subnet info returned for subnet {subnet_id}, skipping")
+                except Exception as e:
+                    logger.warning(f"Error querying subnet {subnet_id} from storage: {e}, skipping")
+                    continue
+
+            logger.info(
+                f"Retrieved {len(subnets)} subnet(s) by querying individually after storage discovery"
+            )
+            return subnets
+
+        except Exception as e:
+            logger.error(f"Error getting all subnets info individually: {e}")
+            return []
+
+    def get_subnet_data(self, subnet_id: int) -> Optional[SubnetData]:
+        """
+        Get basic subnet data using storage query.
+
+        Args:
+            subnet_id: The subnet ID to query
+
+        Returns:
+            SubnetData if found, None otherwise
+        """
+        try:
+            # Query subnet data from storage
+            result = self.substrate.query(
+                module="Network", storage_function="SubnetsData", params=[subnet_id]
+            )
+
+            if not result.value:
+                return None
+
+            # Convert to SubnetData using scalecodec
+            # The result.value is already decoded by substrate-interface
+            # but we can re-encode and decode with scalecodec for consistency
+            return SubnetData(
+                id=result.value["id"],
+                friendly_id=(
+                    result.value["friendly_id"]
+                    if "friendly_id" in result.value
+                    else result.value["id"]
+                ),
+                name=result.value["name"],
+                repo=result.value["repo"],
+                description=result.value["description"],
+                misc=result.value["misc"],
+                state=result.value["state"],
+                start_epoch=result.value["start_epoch"],
+            )
+
+        except Exception as e:
+            logger.error(f"Error getting subnet data: {e}")
+            return None
+
+    def get_subnet_bootnodes(self, subnet_id: int) -> dict[str, list[bytes]]:
+        """
+        Get subnet bootnodes using custom RPC method.
+
+        Args:
+            subnet_id: The subnet ID
+
+        Returns:
+            Dictionary containing 'bootnodes' and 'node_bootnodes' lists
+        """
+        try:
+            # Use custom RPC method
+            result = self.substrate.rpc_request(
+                method="network_getBootnodes", params=[subnet_id]
+            )
+
+            if not result or not result.get("result"):
+                return {"bootnodes": [], "node_bootnodes": []}
+
+            # Decode the SCALE bytes using centralized type registry
+            scale_data = result["result"]
+            if isinstance(scale_data, str) and scale_data.startswith("0x"):
+                scale_data = bytes.fromhex(scale_data[2:])
+            elif isinstance(scale_data, (list, tuple)):
+                scale_data = bytes(scale_data)
+
+            from scalecodec import ScaleBytes
+            from ...utils.blockchain.type_registry import get_rpc_runtime_config
+
+            # Use centralized type registry configuration
+            runtime_config = get_rpc_runtime_config()
+
+            # Decode using AllSubnetBootnodes struct
+            # This contains both official bootnodes and node bootnodes
+            obj = runtime_config.create_scale_object(
+                "AllSubnetBootnodes", ScaleBytes(scale_data)
+            )
+            decoded = obj.decode()
+
+            # Helper to convert byte arrays/lists to bytes
+            def ensure_bytes(item):
+                if isinstance(item, list):
+                    return bytes(item)
+                return item
+
+            # Process the decoded dictionary
+            bootnodes = []
+            node_bootnodes = []
+
+            if isinstance(decoded, dict):
+                # Official bootnodes
+                raw_bootnodes = decoded.get("bootnodes", [])
+                bootnodes = [ensure_bytes(item) for item in raw_bootnodes]
+                
+                # Node bootnodes
+                raw_node_bootnodes = decoded.get("node_bootnodes", [])
+                node_bootnodes = [ensure_bytes(item) for item in raw_node_bootnodes]
+
+            return {
+                "bootnodes": bootnodes, 
+                "node_bootnodes": node_bootnodes
+            }
+
+        except Exception as e:
+            logger.error(f"Error getting subnet bootnodes: {e}")
+            return {"bootnodes": [], "node_bootnodes": []}
+
+    def proof_of_stake(
+        self, subnet_id: int, peer_id: bytes, min_class: int = 0
+    ) -> bool:
+        """
+        Check proof of stake for a peer ID in a subnet.
+
+        Args:
+            subnet_id: The subnet ID
+            peer_id: The peer ID to check
+            min_class: Minimum class requirement
+
+        Returns:
+            True if proof of stake is valid, False otherwise
+        """
+        try:
+            # Use custom RPC method
+            result = self.substrate.rpc_request(
+                method="network_proofOfStake",
+                params=[subnet_id, peer_id.hex(), min_class],
+            )
+
+            if not result or not result.get("result"):
+                return False
+
+            return result["result"]
+
+        except Exception as e:
+            logger.error(f"Error checking proof of stake: {e}")
+            return False
+
+    def get_elected_validator_info(
+        self, subnet_id: int, subnet_epoch: int
+    ) -> Optional[SubnetNodeInfo]:
+        """
+        Get elected validator information for a subnet and epoch using custom RPC method.
+
+        Returns Option<SubnetNodeInfo> - the elected validator node information.
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_epoch: The subnet epoch number
+
+        Returns:
+            SubnetNodeInfo for the elected validator, or None if not found or error
+
+        """
+        if self.substrate is None:
+            logger.error(
+                "Cannot get elected validator info: not connected to blockchain"
+            )
+            return None
+
+        try:
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getElectedValidatorInfo",
+                params=[subnet_id, subnet_epoch],
+            )
+
+            if not result or not result.get("result"):
+                return None
+
+            result_data = result["result"]
+
+            # Decode Option<SubnetNodeInfo> using custom type registry
+            # This returns the same structure as get_subnet_node_info
+            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 (same logic as SubnetNodeRpcClient)
+            def to_bytes(val):
+                return (
+                    bytes(val)
+                    if isinstance(val, list)
+                    else (val if isinstance(val, bytes) else 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
+            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["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),
+                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 elected validator info: {e}")
+            return None
+
+    def get_validators_and_attestors(self, subnet_id: int) -> list[SubnetNodeInfo]:
+        """
+        Get validators and attestors for a subnet using custom RPC method.
+
+        Returns Vec<SubnetNodeInfo> - list of validator and attestor node information.
+
+        Args:
+            subnet_id: The subnet ID
+
+        Returns:
+            List of SubnetNodeInfo objects for validators and attestors
+        """
+        if self.substrate is None:
+            logger.error(
+                "Cannot get validators and attestors: not connected to blockchain"
+            )
+            return []
+
+        try:
+            # Call RPC method
+            result = self.substrate.rpc_request(
+                method="network_getValidatorsAndAttestors",
+                params=[subnet_id],
+            )
+
+            if not result or not result.get("result"):
+                return []
+
+            result_data = result["result"]
+
+            # Decode Vec<SubnetNodeInfo> using custom type registry
+            # This returns the same structure as get_subnet_nodes_info
+            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 []
+
+            # Convert to list of SubnetNodeInfo objects (same logic as SubnetNodeRpcClient)
+            def to_bytes(val):
+                return (
+                    bytes(val)
+                    if isinstance(val, list)
+                    else (val if isinstance(val, bytes) else 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),
+                        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),
+                    )
+                    nodes.append(node_info)
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to convert validator/attestor node info: {e}"
+                    )
+                    continue
+
+            return nodes
+
+        except Exception as e:
+            logger.error(f"Error getting validators and attestors: {e}")
+            return []
+
+    def get_subnet_ids_for_coldkey(self, coldkey: str) -> set[int]:
+        """Get all subnet IDs associated with a coldkey.
+
+        Returns subnets where:
+        - Coldkey owns the subnet (SubnetOwner)
+        - Coldkey has nodes in the subnet (ColdkeySubnetNodes)
+
+        Args:
+            coldkey: Coldkey address (hex string starting with 0x) or wallet name
+
+        Returns:
+            Set of subnet IDs associated with the coldkey
+        """
+        if not self.substrate:
+            logger.error("Cannot get subnet IDs: not connected to blockchain")
+            return set()
+
+        subnet_ids = set()
+
+        # Normalize coldkey address (lowercase for Ethereum addresses)
+        if coldkey.startswith("0x"):
+            coldkey = coldkey.lower()
+
+        try:
+            # 1. Query ColdkeySubnetNodes storage (subnets where coldkey has nodes)
+            # This is very efficient - direct lookup
+            try:
+                result = self.substrate.query(
+                    module="Network",
+                    storage_function="ColdkeySubnetNodes",
+                    params=[coldkey],
+                )
+                if result and hasattr(result, "value") and result.value:
+                    # result.value is dict: {subnet_id: [node_ids], ...}
+                    if isinstance(result.value, dict):
+                        subnet_ids.update(int(sid) for sid in result.value.keys())
+                    logger.debug(
+                        f"Found {len(subnet_ids)} subnets with nodes for coldkey {coldkey}"
+                    )
+            except Exception as e:
+                logger.debug(f"Failed to query ColdkeySubnetNodes for {coldkey}: {e}")
+
+            # 2. Query SubnetOwner for all subnets to find owned subnets
+            # Get maximum subnet ID first
+            try:
+                total_subnets_result = self.substrate.query(
+                    module="Network", storage_function="TotalSubnetUids"
+                )
+                max_subnet_id = (
+                    total_subnets_result.value if total_subnets_result else 0
+                )
+
+                # Also check SubnetsData to find actual subnet IDs (handles non-sequential IDs)
+                # Scan a reasonable range
+                scan_range = max(
+                    max_subnet_id, 50
+                )  # Check at least up to TotalSubnetUids or 50
+
+                logger.debug(
+                    f"Scanning SubnetOwner storage for coldkey {coldkey} (range: 1-{scan_range})"
+                )
+
+                owned_count = 0
+                for subnet_id in range(1, scan_range + 1):
+                    try:
+                        owner_result = self.substrate.query(
+                            module="Network",
+                            storage_function="SubnetOwner",
+                            params=[subnet_id],
+                        )
+                        if owner_result and owner_result.value:
+                            owner = self._to_address(owner_result.value)
+                            if owner and owner.lower() == coldkey.lower():
+                                subnet_ids.add(subnet_id)
+                                owned_count += 1
+                    except Exception:
+                        # Subnet doesn't exist or error - continue
+                        continue
+
+                if owned_count > 0:
+                    logger.debug(
+                        f"Found {owned_count} owned subnets for coldkey {coldkey}"
+                    )
+            except Exception as e:
+                logger.warning(
+                    f"Failed to query SubnetOwner for coldkey {coldkey}: {e}"
+                )
+
+            logger.info(
+                f"Total {len(subnet_ids)} unique subnets found for coldkey {coldkey}"
+            )
+            return subnet_ids
+
+        except Exception as e:
+            logger.error(f"Error getting subnet IDs for coldkey {coldkey}: {e}")
+            return set()
+
+    def check_subnet_activation_requirements(self, subnet_id: int) -> dict[str, Any]:
+        """
+        Check if a subnet meets activation requirements including minimum registration epochs.
+
+        Args:
+            subnet_id: The subnet ID to check
+
+        Returns:
+            Dictionary with activation check results including:
+            - can_activate: bool
+            - requirements_met: list[str]
+            - requirements_failed: list[str]
+            - current_epoch: int
+            - registration_epoch: Optional[int]
+            - min_registration_epochs: int
+            - epochs_elapsed: Optional[int]
+            - epochs_remaining: Optional[int]
+            - timeline: dict with block numbers, epochs, and time estimates
+        """
+        try:
+            if not self.substrate:
+                raise Exception("Not connected to blockchain")
+
+            from ..rpc import ChainRpcClient
+
+            chain_rpc = ChainRpcClient(self.substrate)
+            current_epoch = chain_rpc.get_current_epoch()
+            current_block = chain_rpc.get_block_number()
+            
+            # Get epoch length (blocks per epoch) for time calculations
+            epoch_length_result = self.substrate.get_constant("Network", "EpochLength")
+            epoch_length = epoch_length_result.value if epoch_length_result else 100  # Default fallback
+            
+            # Block time in milliseconds (6000ms = 6 seconds per block on Hypertensor)
+            # This is a constant from the runtime (MILLISECS_PER_BLOCK)
+            block_time_ms = 6000
+
+            # Get subnet info to check registration epoch
+            subnet_info = self.get_subnet_info(subnet_id)
+            if not subnet_info:
+                return {
+                    "success": False,
+                    "error": f"Subnet {subnet_id} not found",
+                    "data": {
+                        "subnet_id": subnet_id,
+                        "can_activate": False,
+                        "requirements_met": [],
+                        "requirements_failed": ["Subnet not found"],
+                        "current_epoch": current_epoch,
+                        "current_block": current_block,
+                        "registration_epoch": None,
+                        "min_registration_epochs": None,
+                        "epochs_elapsed": None,
+                        "epochs_remaining": None,
+                        "timeline": None,
+                    },
+                }
+
+
+            registration_epoch = subnet_info.registration_epoch
+
+            # Query MinSubnetRegistrationEpochs from storage
+            min_registration_epochs_result = self.substrate.query(
+                module="Network", storage_function="MinSubnetRegistrationEpochs", params=[]
+            )
+            min_registration_epochs = (
+                min_registration_epochs_result.value
+                if min_registration_epochs_result
+                else None
+            )
+
+            requirements_met = []
+            requirements_failed = []
+
+            # Check minimum registration epochs
+            epochs_elapsed = None
+            epochs_remaining = None
+            min_epochs_met = False
+
+            if current_epoch is not None and registration_epoch is not None:
+                epochs_elapsed = current_epoch - registration_epoch
+                if min_registration_epochs is not None:
+                    epochs_remaining = max(0, min_registration_epochs - epochs_elapsed)
+                    min_epochs_met = epochs_elapsed >= min_registration_epochs
+
+                    if min_epochs_met:
+                        requirements_met.append(
+                            f"Minimum registration epochs met ({epochs_elapsed}/{min_registration_epochs} epochs elapsed)"
+                        )
+                    else:
+                        requirements_failed.append(
+                            f"Minimum registration epochs not met ({epochs_elapsed}/{min_registration_epochs} epochs elapsed, {epochs_remaining} remaining)"
+                        )
+                else:
+                    requirements_failed.append(
+                        "Could not query minimum registration epochs from chain"
+                    )
+            else:
+                if current_epoch is None:
+                    requirements_failed.append("Could not get current epoch")
+                if registration_epoch is None:
+                    requirements_failed.append(
+                        "Subnet registration epoch not found (subnet may already be activated)"
+                    )
+
+            # Check subnet state
+            if subnet_info.state == SubnetState.REGISTERED:
+                requirements_met.append("Subnet is in Registered state")
+            else:
+                requirements_failed.append(
+                    f"Subnet is not in Registered state (current: {subnet_info.state.value if subnet_info.state else 'Unknown'})"
+                )
+
+            # Check minimum active nodes
+            min_subnet_nodes_result = self.substrate.query(
+                module="Network", storage_function="MinSubnetNodes", params=[]
+            )
+            min_subnet_nodes = (
+                min_subnet_nodes_result.value if min_subnet_nodes_result else None
+            )
+
+            total_active_nodes_result = self.substrate.query(
+                module="Network",
+                storage_function="TotalActiveSubnetNodes",
+                params=[subnet_id],
+            )
+            total_active_nodes = (
+                total_active_nodes_result.value if total_active_nodes_result else 0
+            )
+
+            nodes_met = False
+            if min_subnet_nodes is not None:
+                nodes_met = total_active_nodes >= min_subnet_nodes
+                if nodes_met:
+                    requirements_met.append(
+                        f"Minimum nodes met ({total_active_nodes}/{min_subnet_nodes} active nodes)"
+                    )
+                else:
+                    requirements_failed.append(
+                        f"Minimum nodes not met ({total_active_nodes}/{min_subnet_nodes} active nodes, need {min_subnet_nodes - total_active_nodes} more)"
+                    )
+            else:
+                requirements_failed.append("Could not query minimum subnet nodes from chain")
+
+            # Check minimum delegate stake balance
+            total_delegate_stake_result = self.substrate.query(
+                module="Network",
+                storage_function="TotalSubnetDelegateStakeBalance",
+                params=[subnet_id],
+            )
+            total_delegate_stake = (
+                total_delegate_stake_result.value if total_delegate_stake_result else 0
+            )
+
+            # Query MinSubnetDelegateStakeFactor to calculate minimum
+            min_delegate_stake_factor_result = self.substrate.query(
+                module="Network",
+                storage_function="MinSubnetDelegateStakeFactor",
+                params=[],
+            )
+            min_delegate_stake_factor = (
+                min_delegate_stake_factor_result.value
+                if min_delegate_stake_factor_result
+                else None
+            )
+
+            # Get total network issuance for calculation (from Balances pallet)
+            total_issuance_result = self.substrate.query(
+                module="Balances", storage_function="TotalIssuance", params=[]
+            )
+            total_issuance = (
+                total_issuance_result.value if total_issuance_result else None
+            )
+
+            delegate_stake_met = False
+            min_delegate_stake_required = None
+
+            # Try to calculate minimum delegate stake parameters
+            if (
+                min_delegate_stake_factor is not None
+                and total_issuance is not None
+            ):
+                # Simplified calculation: base_min = total_issuance * factor / 1e18
+                # The actual calculation uses get_min_subnet_delegate_stake_balance which
+                # includes node count multiplier, but this gives us a rough estimate
+                base_min = (total_issuance * min_delegate_stake_factor) // (10**18)
+                
+                # Use base_min as minimum
+                min_delegate_stake_required = base_min
+                delegate_stake_met = total_delegate_stake >= min_delegate_stake_required
+
+                if delegate_stake_met:
+                    requirements_met.append(
+                        f"Minimum delegate stake met ({total_delegate_stake / 1e18:.2f} TENSOR >= {min_delegate_stake_required / 1e18:.2f} TENSOR)"
+                    )
+                else:
+                    requirements_failed.append(
+                        f"Minimum delegate stake not met ({total_delegate_stake / 1e18:.2f} TENSOR < {min_delegate_stake_required / 1e18:.2f} TENSOR, need {(min_delegate_stake_required - total_delegate_stake) / 1e18:.2f} more TENSOR)"
+                    )
+            else:
+                if total_delegate_stake == 0:
+                    requirements_failed.append(
+                        "No delegate stake found (need to delegate stake to subnet nodes)"
+                    )
+                else:
+                    requirements_failed.append(
+                        "Could not calculate minimum delegate stake requirement (missing chain parameters)"
+                    )
+
+            # Check subnet reputation (usually redundant but included for completeness)
+            subnet_reputation = subnet_info.reputation if subnet_info.reputation else 0
+            min_reputation_result = self.substrate.query(
+                module="Network", storage_function="MinSubnetReputation", params=[]
+            )
+            min_reputation = (
+                min_reputation_result.value if min_reputation_result else None
+            )
+
+            reputation_met = True  # Usually always met
+            if min_reputation is not None:
+                reputation_met = subnet_reputation >= min_reputation
+                if not reputation_met:
+                    requirements_failed.append(
+                        f"Subnet reputation too low ({subnet_reputation} < {min_reputation})"
+                    )
+
+            # Check if subnet is in valid activation period (registration or enactment period)
+            in_valid_period = False
+            
+            if current_epoch is not None and registration_epoch is not None:
+                # Query SubnetRegistrationEpochs (registration period length)
+                subnet_registration_epochs_result = self.substrate.query(
+                    module="Network", storage_function="SubnetRegistrationEpochs", params=[]
+                )
+                subnet_registration_epochs = (
+                    subnet_registration_epochs_result.value
+                    if subnet_registration_epochs_result
+                    else None
+                )
+                
+                # Query SubnetEnactmentEpochs (enactment period length)
+                subnet_enactment_epochs_result = self.substrate.query(
+                    module="Network", storage_function="SubnetEnactmentEpochs", params=[]
+                )
+                subnet_enactment_epochs = (
+                    subnet_enactment_epochs_result.value
+                    if subnet_enactment_epochs_result
+                    else None
+                )
+                
+                if subnet_registration_epochs is not None and subnet_enactment_epochs is not None:
+                    max_registration_epoch = registration_epoch + subnet_registration_epochs
+                    max_enactment_epoch = max_registration_epoch + subnet_enactment_epochs
+                    
+                    # Check registration period: epoch <= max_registration_epoch
+                    if subnet_info.state == SubnetState.REGISTERED and current_epoch <= max_registration_epoch:
+                        in_valid_period = True
+                        requirements_met.append(
+                            f"In registration period (epoch {current_epoch} <= {max_registration_epoch})"
+                        )
+                    # Check enactment period: max_registration_epoch < epoch <= max_enactment_epoch
+                    elif subnet_info.state == SubnetState.REGISTERED and current_epoch > max_registration_epoch and current_epoch <= max_enactment_epoch:
+                        in_valid_period = True
+                        requirements_met.append(
+                            f"In enactment period (epoch {current_epoch} between {max_registration_epoch + 1} and {max_enactment_epoch})"
+                        )
+                    # Outside valid periods
+                    elif subnet_info.state == SubnetState.REGISTERED:
+                        requirements_failed.append(
+                            f"Subnet is outside valid activation periods (current epoch {current_epoch}, max enactment epoch {max_enactment_epoch})"
+                        )
+                        requirements_failed.append(
+                            "⚠️  Subnet will be removed if activation is attempted now!"
+                        )
+                else:
+                    requirements_failed.append(
+                        "Could not query registration/enactment epoch periods from chain"
+                    )
+            else:
+                requirements_failed.append(
+                    "Could not determine if subnet is in valid activation period (missing epoch data)"
+                )
+
+            # Check if subnet can be activated (all critical requirements met)
+            can_activate = (
+                min_epochs_met
+                and subnet_info.state == SubnetState.REGISTERED
+                and nodes_met
+                and delegate_stake_met
+                and reputation_met
+                and in_valid_period
+                and current_epoch is not None
+                and registration_epoch is not None
+            )
+
+            # Build comprehensive timeline information
+            timeline = None
+            if registration_epoch is not None and current_epoch is not None:
+                # Calculate registration block (approximate)
+                # registration_block = current_block - (epochs_elapsed * epoch_length)
+                registration_block = None
+                if current_block is not None and epochs_elapsed is not None:
+                    registration_block = current_block - (epochs_elapsed * epoch_length)
+                
+                # Get period lengths
+                subnet_registration_epochs_result = self.substrate.query(
+                    module="Network", storage_function="SubnetRegistrationEpochs", params=[]
+                )
+                subnet_registration_epochs = (
+                    subnet_registration_epochs_result.value
+                    if subnet_registration_epochs_result
+                    else None
+                )
+                
+                subnet_enactment_epochs_result = self.substrate.query(
+                    module="Network", storage_function="SubnetEnactmentEpochs", params=[]
+                )
+                subnet_enactment_epochs = (
+                    subnet_enactment_epochs_result.value
+                    if subnet_enactment_epochs_result
+                    else None
+                )
+                
+                # Calculate key milestones
+                min_activation_epoch = None
+                registration_deadline_epoch = None
+                enactment_deadline_epoch = None
+                
+                if min_registration_epochs is not None:
+                    min_activation_epoch = registration_epoch + min_registration_epochs
+                
+                if subnet_registration_epochs is not None:
+                    registration_deadline_epoch = registration_epoch + subnet_registration_epochs
+                
+                if subnet_registration_epochs is not None and subnet_enactment_epochs is not None:
+                    enactment_deadline_epoch = registration_epoch + subnet_registration_epochs + subnet_enactment_epochs
+                
+                # Calculate time estimates (in seconds, human-readable, and datetime)
+                from datetime import datetime, timedelta
+                
+                def epochs_to_time(num_epochs: int, is_past: bool = False) -> dict:
+                    """Convert epochs to time estimates with datetime.
+                    
+                    Args:
+                        num_epochs: Number of epochs to convert
+                        is_past: If True, subtract from now (for past events), otherwise add (for future)
+                    """
+                    total_blocks = num_epochs * epoch_length
+                    total_ms = total_blocks * block_time_ms
+                    total_seconds = total_ms / 1000
+                    total_minutes = total_seconds / 60
+                    total_hours = total_minutes / 60
+                    total_days = total_hours / 24
+                    
+                    # Build human readable string
+                    if total_days >= 1:
+                        human_readable = f"{total_days:.1f} days"
+                    elif total_hours >= 1:
+                        human_readable = f"{total_hours:.1f} hours"
+                    elif total_minutes >= 1:
+                        human_readable = f"{total_minutes:.0f} minutes"
+                    else:
+                        human_readable = f"{total_seconds:.0f} seconds"
+                    
+                    # Calculate datetime (in local timezone)
+                    now = datetime.now()
+                    if is_past:
+                        target_datetime = now - timedelta(seconds=total_seconds)
+                    else:
+                        target_datetime = now + timedelta(seconds=total_seconds)
+                    
+                    # Format datetime for display
+                    datetime_str = target_datetime.strftime("%Y-%m-%d %H:%M:%S")
+                    datetime_short = target_datetime.strftime("%b %d, %H:%M")
+                    
+                    return {
+                        "epochs": num_epochs,
+                        "blocks": total_blocks,
+                        "seconds": int(total_seconds),
+                        "human_readable": human_readable,
+                        "datetime": datetime_str,
+                        "datetime_short": datetime_short,
+                    }
+                
+                # Time until key milestones
+                time_until_min_activation = None
+                time_until_registration_deadline = None
+                time_until_enactment_deadline = None
+                
+                if min_activation_epoch is not None:
+                    epochs_until = max(0, min_activation_epoch - current_epoch)
+                    if epochs_until > 0:
+                        time_until_min_activation = epochs_to_time(epochs_until)
+                    else:
+                        time_until_min_activation = {"epochs": 0, "blocks": 0, "seconds": 0, "human_readable": "Now eligible"}
+                
+                if registration_deadline_epoch is not None:
+                    epochs_until = max(0, registration_deadline_epoch - current_epoch)
+                    if epochs_until > 0:
+                        time_until_registration_deadline = epochs_to_time(epochs_until)
+                    else:
+                        time_until_registration_deadline = {"epochs": 0, "blocks": 0, "seconds": 0, "human_readable": "Passed"}
+                
+                if enactment_deadline_epoch is not None:
+                    epochs_until = max(0, enactment_deadline_epoch - current_epoch)
+                    if epochs_until > 0:
+                        time_until_enactment_deadline = epochs_to_time(epochs_until)
+                    else:
+                        time_until_enactment_deadline = {"epochs": 0, "blocks": 0, "seconds": 0, "human_readable": "Passed - subnet at risk!"}
+                
+                # Calculate registration datetime (past event)
+                registration_datetime = None
+                if epochs_elapsed is not None and epochs_elapsed > 0:
+                    registration_time = epochs_to_time(epochs_elapsed, is_past=True)
+                    registration_datetime = registration_time.get("datetime")
+                
+                # Determine current phase
+                current_phase = "Unknown"
+                if current_epoch < min_activation_epoch if min_activation_epoch else False:
+                    current_phase = "Waiting Period (cannot activate yet)"
+                elif registration_deadline_epoch and current_epoch <= registration_deadline_epoch:
+                    current_phase = "Registration Period"
+                elif enactment_deadline_epoch and current_epoch <= enactment_deadline_epoch:
+                    current_phase = "Enactment Period (must activate or will be removed)"
+                elif enactment_deadline_epoch and current_epoch > enactment_deadline_epoch:
+                    current_phase = "Expired (will be removed on activation attempt)"
+                
+                timeline = {
+                    "current_block": current_block,
+                    "current_epoch": current_epoch,
+                    "registration_epoch": registration_epoch,
+                    "registration_block_approx": registration_block,
+                    "registration_datetime": registration_datetime,
+                    "epoch_length": epoch_length,
+                    "block_time_ms": block_time_ms,
+                    "min_activation_epoch": min_activation_epoch,
+                    "registration_deadline_epoch": registration_deadline_epoch,
+                    "enactment_deadline_epoch": enactment_deadline_epoch,
+                    "current_phase": current_phase,
+                    "time_until_min_activation": time_until_min_activation,
+                    "time_until_registration_deadline": time_until_registration_deadline,
+                    "time_until_enactment_deadline": time_until_enactment_deadline,
+                    "subnet_registration_epochs": subnet_registration_epochs,
+                    "subnet_enactment_epochs": subnet_enactment_epochs,
+                }
+
+            return {
+                "success": True,
+                "data": {
+                    "subnet_id": subnet_id,
+                    "can_activate": can_activate,
+                    "requirements_met": requirements_met,
+                    "requirements_failed": requirements_failed,
+                    "current_epoch": current_epoch,
+                    "current_block": current_block,
+                    "registration_epoch": registration_epoch,
+                    "min_registration_epochs": min_registration_epochs,
+                    "epochs_elapsed": epochs_elapsed,
+                    "epochs_remaining": epochs_remaining,
+                    "subnet_state": subnet_info.state.value if subnet_info.state else None,
+                    "total_active_nodes": total_active_nodes,
+                    "min_subnet_nodes": min_subnet_nodes,
+                    "total_delegate_stake": total_delegate_stake,
+                    "min_delegate_stake_required": min_delegate_stake_required,
+                    "timeline": timeline,
+                },
+            }
+
+        except Exception as e:
+            logger.error(f"Error checking activation requirements: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "data": {
+                    "subnet_id": subnet_id,
+                    "can_activate": False,
+                    "requirements_met": [],
+                    "requirements_failed": [f"Error checking requirements: {str(e)}"],
+                    "current_epoch": None,
+                    "registration_epoch": None,
+                    "min_registration_epochs": None,
+                    "epochs_elapsed": None,
+                    "epochs_remaining": None,
+                },
+            }