htcli 1.1.0__py3-none-any.whl

src/htcli/utils/blockchain/type_registry.py

@@ -0,0 +1,1373 @@
+"""
+Custom type registry for SCALE codec decoding of Hypertensor blockchain types.
+
+This module provides the complete type definitions needed to properly decode
+RPC responses from the Hypertensor blockchain. The type definitions must match
+the Rust struct definitions in hypertensor-evm/pallets/network/src/lib.rs exactly.
+
+Reference:
+- mesh-template/mesh/substrate/chain_data.py (lines 11-258)
+- hypertensor-evm/pallets/network/src/lib.rs (SubnetInfo line 1082, SubnetNodeInfo line 1184)
+"""
+
+import copy
+
+from scalecodec import ScaleBytes
+from scalecodec.base import RuntimeConfiguration
+from scalecodec.exceptions import RemainingScaleBytesNotEmptyException
+from scalecodec.type_registry import load_type_registry_preset
+
+from ..logging import get_logger
+
+logger = get_logger(__name__)
+
+# Complete custom type registry matching hypertensor-evm blockchain structures
+# Field order MUST match Rust struct definitions exactly for SCALE decoding
+CUSTOM_RPC_TYPE_REGISTRY = {
+    "types": {
+        # RegistrationSubnetData (used for subnet registration)
+        "RegistrationSubnetData": {
+            "type": "struct",
+            "type_mapping": [
+                ["name", "Vec<u8>"],
+                ["repo", "Vec<u8>"],
+                ["description", "Vec<u8>"],
+                ["misc", "Vec<u8>"],
+                ["min_stake", "u128"],
+                ["max_stake", "u128"],
+                ["delegate_stake_percentage", "u128"],
+                ["initial_validators", "BTreeMap<u32, u32>"],
+                [
+                    "bootnodes",
+                    "BTreeMap<PeerId, BoundedVec<u8, DefaultMaxVectorLength>>",
+                ],
+            ],
+        },
+        # Subnet Data (basic registration data)
+        "SubnetData": {
+            "type": "struct",
+            "type_mapping": [
+                ["id", "u32"],
+                ["friendly_id", "u32"],
+                ["name", "Vec<u8>"],
+                ["repo", "Vec<u8>"],
+                ["description", "Vec<u8>"],
+                ["misc", "Vec<u8>"],
+                ["state", "SubnetState"],
+                ["start_epoch", "u32"],
+            ],
+        },
+        # Complete Subnet Info (RPC helper with aggregated data)
+        # Reference: hypertensor-evm/pallets/network/src/lib.rs lines 1082-1116
+        "SubnetInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["id", "u32"],
+                ["friendly_id", "Option<u32>"],
+                ["name", "Vec<u8>"],
+                ["repo", "Vec<u8>"],
+                ["description", "Vec<u8>"],
+                ["misc", "Vec<u8>"],
+                ["state", "SubnetState"],
+                ["start_epoch", "u32"],
+                ["churn_limit", "u32"],
+                # NOTE: churn_limit_multiplier exists in Rust struct but is NOT included
+                # in the RPC SubnetInfo response from the deployed testnet. Removed to fix
+                # SCALE decoding alignment issue.
+                ["min_stake", "u128"],
+                ["max_stake", "u128"],
+                ["queue_immunity_epochs", "u32"],
+                ["target_node_registrations_per_epoch", "u32"],
+                ["node_registrations_this_epoch", "u32"],
+                ["subnet_node_queue_epochs", "u32"],
+                ["idle_classification_epochs", "u32"],
+                ["included_classification_epochs", "u32"],
+                ["delegate_stake_percentage", "u128"],
+                ["last_delegate_stake_rewards_update", "u32"],
+                ["node_burn_rate_alpha", "u128"],
+                ["current_node_burn_rate", "u128"],
+                ["initial_coldkeys", "Option<BTreeMap<[u8; 20], u32>>"],
+                ["initial_coldkey_data", "Option<BTreeMap<[u8; 20], u32>>"],
+                ["max_registered_nodes", "u32"],
+                ["owner", "Option<[u8; 20]>"],
+                ["pending_owner", "Option<[u8; 20]>"],
+                ["registration_epoch", "Option<u32>"],
+                ["prev_pause_epoch", "u32"],
+                ["key_types", "BTreeSet<KeyType>"],
+                ["slot_index", "Option<u32>"],
+                ["slot_assignment", "Option<u32>"],
+                ["subnet_node_min_weight_decrease_reputation_threshold", "u128"],
+                ["reputation", "u128"],
+                ["min_subnet_node_reputation", "u128"],
+                ["absent_decrease_reputation_factor", "u128"],
+                ["included_increase_reputation_factor", "u128"],
+                ["below_min_weight_decrease_reputation_factor", "u128"],
+                ["non_attestor_decrease_reputation_factor", "u128"],
+                ["non_consensus_attestor_decrease_reputation_factor", "u128"],
+                ["validator_absent_subnet_node_reputation_factor", "u128"],
+                ["validator_non_consensus_subnet_node_reputation_factor", "u128"],
+                ["bootnode_access", "BTreeSet<[u8; 20]>"],
+                ["bootnodes", "BTreeSet<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["total_nodes", "u32"],
+                ["total_active_nodes", "u32"],
+                ["total_electable_nodes", "u32"],
+                ["current_min_delegate_stake", "u128"],
+                ["total_subnet_stake", "u128"],
+                ["total_subnet_delegate_stake_shares", "u128"],
+                ["total_subnet_delegate_stake_balance", "u128"],
+            ],
+        },
+        # Subnet State enum
+        "SubnetState": {
+            "type": "enum",
+            "value_list": [
+                "Registered",
+                "Active",
+                "Paused",
+            ],
+        },
+        # Key Type enum (cryptographic key types)
+        "KeyType": {
+            "type": "enum",
+            "value_list": [
+                "Rsa",
+                "Ed25519",
+                "Secp256k1",
+                "Ecdsa",
+            ],
+        },
+        # Subnet Node Classification (node class and epoch)
+        "SubnetNodeClassification": {
+            "type": "struct",
+            "type_mapping": [
+                ["node_class", "SubnetNodeClass"],
+                ["start_epoch", "u32"],
+            ],
+        },
+        "SubnetNodeClass": {
+            "type": "enum",
+            "value_list": [
+                "Registered",
+                "Idle",
+                "Included",
+                "Validator",
+            ],
+        },
+        # Subnet Node (core node data)
+        "SubnetNode": {
+            "type": "struct",
+            "type_mapping": [
+                ["id", "u32"],
+                ["hotkey", "[u8; 20]"],
+                ["peer_id", "PeerId"],
+                ["bootnode_peer_id", "PeerId"],
+                ["client_peer_id", "PeerId"],
+                ["bootnode", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["classification", "SubnetNodeClassification"],
+                ["delegate_reward_rate", "u128"],
+                ["last_delegate_reward_rate_update", "u32"],
+                ["unique", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["non_unique", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+            ],
+        },
+        # Subnet Node Info (RPC helper with aggregated data)
+        # Reference: hypertensor-evm/pallets/network/src/lib.rs lines 1184-1203
+        "SubnetNodeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_id", "u32"],
+                ["subnet_node_id", "u32"],
+                ["coldkey", "[u8; 20]"],
+                ["hotkey", "[u8; 20]"],
+                ["peer_id", "PeerId"],
+                ["bootnode_peer_id", "PeerId"],
+                ["client_peer_id", "PeerId"],
+                ["bootnode", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["identity", "ColdkeyIdentityData"],
+                ["classification", "SubnetNodeClassification"],
+                ["delegate_reward_rate", "u128"],
+                ["last_delegate_reward_rate_update", "u32"],
+                ["unique", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["non_unique", "Option<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["stake_balance", "u128"],
+                ["total_node_delegate_stake_shares", "u128"],
+                ["node_delegate_stake_balance", "u128"],
+                ["coldkey_reputation", "Reputation"],
+                ["subnet_node_reputation", "u128"],
+                ["node_slot_index", "Option<u32>"],
+                ["consecutive_idle_epochs", "u32"],
+                ["consecutive_included_epochs", "u32"],
+            ],
+        },
+        "ColdkeyIdentityData": {
+            "type": "struct",
+            "type_mapping": [
+                ["name", "BoundedVec<u8, DefaultMaxVectorLength>"],
+                ["url", "BoundedVec<u8, DefaultMaxUrlLength>"],
+                ["image", "BoundedVec<u8, DefaultMaxUrlLength>"],
+                ["discord", "BoundedVec<u8, DefaultMaxSocialIdLength>"],
+                ["x", "BoundedVec<u8, DefaultMaxSocialIdLength>"],
+                ["telegram", "BoundedVec<u8, DefaultMaxSocialIdLength>"],
+                ["github", "BoundedVec<u8, DefaultMaxUrlLength>"],
+                ["hugging_face", "BoundedVec<u8, DefaultMaxUrlLength>"],
+                ["description", "BoundedVec<u8, DefaultMaxVectorLength>"],
+                ["misc", "BoundedVec<u8, DefaultMaxVectorLength>"],
+            ],
+        },
+        # Reputation
+        "Reputation": {
+            "type": "struct",
+            "type_mapping": [
+                ["start_epoch", "u32"],
+                ["score", "u128"],
+                ["lifetime_node_count", "u32"],
+                ["total_active_nodes", "u32"],
+                ["total_increases", "u32"],
+                ["total_decreases", "u32"],
+                ["average_attestation", "u128"],
+                ["last_validator_epoch", "u32"],
+                ["ow_score", "u128"],
+            ],
+        },
+        # Stake Info structures
+        "SubnetNodeStakeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_id", "Option<u32>"],
+                ["subnet_node_id", "Option<u32>"],
+                ["hotkey", "[u8; 20]"],
+                ["balance", "u128"],
+            ],
+        },
+        "NodeStakeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_id", "Option<u32>"],
+                ["subnet_node_id", "Option<u32>"],
+                ["balance", "u128"],
+            ],
+        },
+        "DelegateStakeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_id", "u32"],
+                ["shares", "u128"],
+                ["balance", "u128"],
+            ],
+        },
+        "NodeDelegateStakeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_id", "u32"],
+                ["subnet_node_id", "u32"],
+                ["shares", "u128"],
+                ["balance", "u128"],
+            ],
+        },
+        # Consensus structures
+        "SubnetNodeConsensusData": {
+            "type": "struct",
+            "type_mapping": [
+                ["subnet_node_id", "u32"],
+                ["score", "u128"],
+            ],
+        },
+        "AttestEntry": {
+            "type": "struct",
+            "type_mapping": [
+                ["block", "u32"],
+                ["attestor_progress", "u128"],
+                ["reward_factor", "u128"],
+                ["data", "Option<BoundedVec<u8, DefaultValidatorArgsLimit>>"],
+            ],
+        },
+        "ConsensusData": {
+            "type": "struct",
+            "type_mapping": [
+                ["validator_id", "u32"],
+                ["block", "u32"],
+                ["validator_epoch_progress", "u128"],
+                ["validator_reward_factor", "u128"],
+                ["attests", "BTreeMap<u32, AttestEntry>"],
+                ["subnet_nodes", "Vec<SubnetNode<[u8; 20]>>"],
+                ["prioritize_queue_node_id", "Option<u32>"],
+                ["remove_queue_node_id", "Option<u32>"],
+                ["data", "Vec<SubnetNodeConsensusData>"],
+                ["args", "Option<BoundedVec<u8, DefaultValidatorArgsLimit>>"],
+            ],
+        },
+        "ConsensusSubmissionData": {
+            "type": "struct",
+            "type_mapping": [
+                ["validator_subnet_node_id", "u32"],
+                ["validator_epoch_progress", "u128"],
+                ["validator_reward_factor", "u128"],
+                ["attestation_ratio", "u128"],
+                ["weight_sum", "u128"],
+                ["data_length", "u32"],
+                ["data", "Vec<SubnetNodeConsensusData>"],
+                ["attests", "BTreeMap<u32, AttestEntry>"],
+                ["subnet_nodes", "Vec<SubnetNode<[u8; 20]>>"],
+                ["prioritize_queue_node_id", "Option<u32>"],
+                ["remove_queue_node_id", "Option<u32>"],
+            ],
+        },
+        "RewardsData": {
+            "type": "struct",
+            "type_mapping": [
+                ["overall_subnet_reward", "u128"],
+                ["subnet_owner_reward", "u128"],
+                ["subnet_rewards", "u128"],
+                ["delegate_stake_rewards", "u128"],
+                ["subnet_node_rewards", "u128"],
+            ],
+        },
+        "AllSubnetBootnodes": {
+            "type": "struct",
+            "type_mapping": [
+                ["bootnodes", "BTreeSet<BoundedVec<u8, DefaultMaxVectorLength>>"],
+                ["node_bootnodes", "BTreeSet<BoundedVec<u8, DefaultMaxVectorLength>>"],
+            ],
+        },
+        # Overwatch Node types
+        # Reference: hypertensor-evm/pallets/network/src/lib.rs lines 1741-1744
+        "OverwatchNode": {
+            "type": "struct",
+            "type_mapping": [
+                ["id", "u32"],
+                ["hotkey", "[u8; 20]"],
+            ],
+        },
+        # Reference: hypertensor-evm/pallets/network/src/lib.rs lines 1721-1727
+        "OverwatchNodeInfo": {
+            "type": "struct",
+            "type_mapping": [
+                ["overwatch_node_id", "u32"],
+                ["coldkey", "[u8; 20]"],
+                ["hotkey", "[u8; 20]"],
+                ["peer_ids", "Vec<PeerId>"],
+                ["reputation", "Reputation"],
+            ],
+        },
+        # Type aliases for bounded vectors and collections
+        "PeerId": "Vec<u8>",
+        "OpaquePeerId": "Vec<u8>",
+        # AccountId is AccountId20 which is [u8; 20]
+        "AccountId": "[u8; 20]",
+        "BTreeSet<KeyType>": "Vec<KeyType>",
+        "BTreeSet<[u8; 20]>": "Vec<[u8; 20]>",
+        "BTreeSet<BoundedVec<u8, DefaultMaxVectorLength>>": "Vec<BoundedVec<u8, DefaultMaxVectorLength>>",
+        "BTreeMap<[u8; 20], u32>": "Vec<([u8; 20], u32)>",  # BTreeMap decoded as Vec of tuples
+        "BTreeMap<AccountId, u32>": "Vec<([u8; 20], u32)>",  # AccountId is [u8; 20]
+        "BTreeMap<u32, AttestEntry>": "Vec<(u32, AttestEntry)>",
+        "BoundedVec<u8, DefaultMaxVectorLength>": "Vec<u8>",
+        "BoundedVec<u8, DefaultMaxUrlLength>": "Vec<u8>",
+        "BoundedVec<u8, DefaultMaxSocialIdLength>": "Vec<u8>",
+        "BoundedVec<u8, DefaultValidatorArgsLimit>": "Vec<u8>",
+        "Option<BoundedVec<u8, DefaultMaxVectorLength>>": "Option<Vec<u8>>",
+        "Option<BoundedVec<u8, DefaultMaxUrlLength>>": "Option<Vec<u8>>",
+        "Option<BoundedVec<u8, DefaultMaxSocialIdLength>>": "Option<Vec<u8>>",
+        "Option<BoundedVec<u8, DefaultValidatorArgsLimit>>": "Option<Vec<u8>>",
+        "Option<BTreeMap<[u8; 20], u32>>": "Option<Vec<([u8; 20], u32)>>",
+    }
+}
+
+LEGACY_RPC_TYPE_REGISTRY = copy.deepcopy(CUSTOM_RPC_TYPE_REGISTRY)
+LEGACY_RPC_TYPE_REGISTRY["types"]["SubnetData"]["type_mapping"] = [
+    mapping
+    for mapping in CUSTOM_RPC_TYPE_REGISTRY["types"]["SubnetData"]["type_mapping"]
+    if mapping[0] != "friendly_id"
+]
+LEGACY_RPC_TYPE_REGISTRY["types"]["SubnetInfo"]["type_mapping"] = [
+    mapping
+    for mapping in CUSTOM_RPC_TYPE_REGISTRY["types"]["SubnetInfo"]["type_mapping"]
+    if mapping[0] != "friendly_id"
+]
+
+
+def get_rpc_runtime_config(use_legacy: bool = False) -> RuntimeConfiguration:
+    """
+    Get properly configured RuntimeConfiguration for RPC SCALE decoding.
+
+    This creates a RuntimeConfiguration with both the legacy type registry
+    and our custom Hypertensor types, matching the pattern from mesh-template.
+
+    Args:
+        use_legacy: Build a config that matches the legacy subnet schema.
+
+    Returns:
+        RuntimeConfiguration configured for decoding Hypertensor RPC responses.
+    """
+    config = RuntimeConfiguration()
+    config.update_type_registry(load_type_registry_preset("legacy"))
+    config.update_type_registry(
+        LEGACY_RPC_TYPE_REGISTRY if use_legacy else CUSTOM_RPC_TYPE_REGISTRY
+    )
+    return config
+
+
+def _normalize_scale_input(data):
+    if isinstance(data, list):
+        return bytes(data)
+    if isinstance(data, str):
+        hex_data = data[2:] if data.startswith("0x") else data
+        return bytes.fromhex(hex_data)
+    if isinstance(data, bytes):
+        return data
+    return bytes(data)
+
+
+def _decode_scale_object(data, type_name: str, allow_legacy_fallback: bool = False):
+    normalized = _normalize_scale_input(data)
+    configs = [get_rpc_runtime_config()]
+    if allow_legacy_fallback:
+        configs.append(get_rpc_runtime_config(use_legacy=True))
+
+    last_error: Exception | None = None
+    for idx, config in enumerate(configs):
+        obj = config.create_scale_object(type_name)
+        try:
+            decoded = obj.decode(ScaleBytes(normalized))
+            if allow_legacy_fallback and idx == 1:
+                logger.info("Decoded %s with legacy registry", type_name)
+            return decoded
+        except RemainingScaleBytesNotEmptyException as exc:
+            last_error = exc
+            if allow_legacy_fallback and idx == 0:
+                logger.warning(
+                    "Remaining SCALE bytes when decoding %s with latest schema (%s); "
+                    "retrying legacy registry",
+                    type_name,
+                    exc,
+                )
+                continue
+            raise
+        except Exception as exc:  # pragma: no cover
+            last_error = exc
+            if allow_legacy_fallback and idx == 0:
+                logger.warning(
+                    "Error decoding %s with latest schema (%s); retrying legacy registry",
+                    type_name,
+                    exc,
+                )
+                continue
+            raise
+
+    if last_error:
+        raise last_error
+    return None
+
+
+def decode_option_subnet_info(data: bytes) -> dict:
+    """
+    Decode Option<SubnetInfo> from SCALE bytes.
+
+    This function handles the case where decoding raises RemainingScaleBytesNotEmptyException
+    but the decoded value is still available in obj.value. It uses the same approach as
+    decode_vec_subnet_info - decode the SubnetInfo directly and extract the value even when
+    an exception is raised.
+
+    Args:
+        data: SCALE-encoded bytes (list of ints or bytes object)
+
+    Returns:
+        Decoded SubnetInfo dict or None if subnet not found
+    """
+    normalized = _normalize_scale_input(data)
+    if not normalized:
+        return None
+
+    config = get_rpc_runtime_config()
+
+    # Check first byte to see if Option is Some (0x01) or None (0x00)
+    if len(normalized) == 0:
+        return None
+
+    option_byte = normalized[0]
+    if option_byte == 0x00:
+        # Option::None
+        return None
+    elif option_byte == 0x01:
+        # Option::Some - decode the SubnetInfo
+        # Skip the Option discriminant byte (0x01)
+        subnet_bytes = normalized[1:]
+
+        # Decode SubnetInfo directly (same approach as decode_vec_subnet_info)
+        subnet_obj = config.create_scale_object("SubnetInfo")
+        try:
+            subnet_obj.decode(ScaleBytes(subnet_bytes))
+            # Decode succeeded without exception
+        except RemainingScaleBytesNotEmptyException:
+            # Exception is expected - scalecodec sets obj.value before raising it
+            pass
+        except Exception as e:
+            logger.error(f"Failed to decode SubnetInfo in Option: {e}")
+            return None
+
+        # Extract decoded value (always set even when exception was raised)
+        if hasattr(subnet_obj, "value") and subnet_obj.value:
+            return subnet_obj.value
+
+        logger.error("Failed to decode SubnetInfo from Option - no value extracted")
+        return None
+    else:
+        logger.error(f"Invalid Option discriminant byte: {option_byte}")
+        return None
+
+
+def decode_vec_subnet_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<SubnetInfo> from SCALE bytes.
+
+    This function attempts to decode the entire Vec<SubnetInfo> at once using scalecodec,
+    and extracts all decoded values from the Vec object even if exceptions are raised.
+
+    Args:
+        data: SCALE-encoded bytes (includes Vec length byte at the start)
+
+    Returns:
+        List of decoded SubnetInfo dicts
+    """
+    normalized = _normalize_scale_input(data)
+    if not normalized:
+        logger.warning("No data provided to decode_vec_subnet_info")
+        return []
+
+    config = get_rpc_runtime_config()
+
+    try:
+        # Try direct Vec decoding - scalecodec should handle Vec<SubnetInfo>
+        vec_obj = config.create_scale_object("Vec<SubnetInfo>")
+
+        # Decode and catch exceptions - value may still be populated
+        exception_occurred = False
+        exception_msg = None
+        try:
+            vec_obj.decode(ScaleBytes(normalized))
+            logger.debug("Vec<SubnetInfo> decoded without exception")
+        except RemainingScaleBytesNotEmptyException as e:
+            # This is expected - Vec decoding may raise this even when values are decoded
+            exception_occurred = True
+            exception_msg = str(e)
+            logger.debug(
+                f"RemainingScaleBytesNotEmptyException during Vec decode: {exception_msg}"
+            )
+        except Exception as e:
+            logger.warning(
+                f"Exception during Vec decode: {e}, trying to extract partial results"
+            )
+            exception_occurred = True
+            exception_msg = str(e)
+
+        # Try to extract decoded values from the Vec object
+        # scalecodec's Vec type stores elements in different places depending on the state
+        decoded_list = None
+
+        # Method 1: Direct value attribute (most common)
+        if hasattr(vec_obj, "value") and vec_obj.value is not None:
+            decoded_list = vec_obj.value
+            logger.debug(
+                f"Found value in vec_obj.value: {type(decoded_list)}, length: {len(decoded_list) if isinstance(decoded_list, list) else 'N/A'}"
+            )
+
+        # Method 2: Check if Vec has a value_list attribute (some Vec implementations)
+        if (
+            decoded_list is None
+            or (isinstance(decoded_list, list) and len(decoded_list) == 0)
+        ) and hasattr(vec_obj, "value_list"):
+            if vec_obj.value_list:
+                decoded_list = vec_obj.value_list
+                logger.debug(
+                    f"Found value in vec_obj.value_list: {len(decoded_list)} items"
+                )
+
+        # Method 3: Try to access elements via Vec's internal structure
+        # scalecodec Vec objects may have _elements or elements attributes
+        if decoded_list is None or (
+            isinstance(decoded_list, list) and len(decoded_list) == 0
+        ):
+            # Try accessing internal elements
+            for attr_name in [
+                "elements",
+                "_elements",
+                "decoded_elements",
+                "value_serialized",
+            ]:
+                if hasattr(vec_obj, attr_name):
+                    try:
+                        attr_value = getattr(vec_obj, attr_name)
+                        if attr_value is not None:
+                            # Check if it's a list or something we can convert
+                            if isinstance(attr_value, list) and len(attr_value) > 0:
+                                decoded_list = attr_value
+                                logger.debug(
+                                    f"Found value in vec_obj.{attr_name}: {len(decoded_list)} items"
+                                )
+                                break
+                            elif hasattr(attr_value, "__iter__") and not isinstance(
+                                attr_value, (str, bytes)
+                            ):
+                                # Try to convert to list
+                                try:
+                                    decoded_list = list(attr_value)
+                                    if decoded_list:
+                                        logger.debug(
+                                            f"Found value in vec_obj.{attr_name} (converted): {len(decoded_list)} items"
+                                        )
+                                        break
+                                except Exception:
+                                    pass
+                    except Exception as attr_err:
+                        logger.debug(
+                            f"Could not access vec_obj.{attr_name}: {attr_err}"
+                        )
+                        continue
+
+        # Normalize to list
+        if decoded_list is not None:
+            if not isinstance(decoded_list, list):
+                decoded_list = [decoded_list]
+
+            # Filter out None values
+            decoded_list = [item for item in decoded_list if item is not None]
+
+            if decoded_list:
+                logger.info(
+                    f"Successfully decoded {len(decoded_list)} subnet(s) from Vec<SubnetInfo> "
+                    f"(exception occurred: {exception_occurred})"
+                )
+                return decoded_list
+
+        logger.warning(
+            "Could not extract decoded values from Vec object using direct Vec decode"
+        )
+        logger.debug(
+            "Attempting to manually process Vec elements using Vec's internal decoder"
+        )
+
+        # Try to use Vec's internal decoder to process elements one by one
+        try:
+            # Access Vec's data and sub_type to decode elements manually
+            vec_length_byte = normalized[0]
+
+            # Read Vec length
+            if (vec_length_byte & 0x03) == 0x00:
+                vec_length = vec_length_byte >> 2
+                element_offset = 1
+            elif (vec_length_byte & 0x03) == 0x01:
+                vec_length = ((vec_length_byte >> 2) | (normalized[1] << 6)) & 0x3FFF
+                element_offset = 2
+            elif (vec_length_byte & 0x03) == 0x02:
+                vec_length = (
+                    ((vec_length_byte >> 2) & 0x3F)
+                    | (normalized[1] << 6)
+                    | (normalized[2] << 14)
+                    | (normalized[3] << 22)
+                ) & 0x3FFFFFFF
+                element_offset = 4
+            else:
+                vec_length = 0
+                element_offset = 1
+
+            logger.debug(
+                f"Vec length from compact encoding: {vec_length}, elements start at offset {element_offset}"
+            )
+
+            # Try to use Vec's sub_type decoder to decode each element
+            if hasattr(vec_obj, "sub_type") and vec_length > 0:
+                decoded_elements = []
+                current_offset = element_offset
+
+                for i in range(vec_length):
+                    if current_offset >= len(normalized):
+                        logger.warning(
+                            f"Ran out of bytes at element {i + 1}/{vec_length}"
+                        )
+                        break
+
+                    # Create a SubnetInfo decoder
+                    element_obj = config.create_scale_object("SubnetInfo")
+                    element_bytes = normalized[current_offset:]
+
+                    try:
+                        element_obj.decode(ScaleBytes(element_bytes))
+                        # Check if we got a value
+                        if (
+                            hasattr(element_obj, "value")
+                            and element_obj.value is not None
+                        ):
+                            decoded_elements.append(element_obj.value)
+                            # Get consumed bytes
+                            if hasattr(element_obj, "data") and hasattr(
+                                element_obj.data, "offset"
+                            ):
+                                consumed = element_obj.data.offset
+                                if 0 < consumed <= len(element_bytes):
+                                    current_offset += consumed
+                                    logger.debug(
+                                        f"Element {i + 1} decoded, consumed {consumed} bytes, new offset: {current_offset}"
+                                    )
+                                else:
+                                    logger.warning(
+                                        f"Invalid consumed bytes {consumed} for element {i + 1}, estimating"
+                                    )
+                                    # Estimate based on average
+                                    estimated = (
+                                        len(normalized) // vec_length
+                                        if vec_length > 0
+                                        else 500
+                                    )
+                                    current_offset += min(estimated, len(element_bytes))
+                            else:
+                                # Estimate
+                                estimated = (
+                                    len(normalized) // vec_length
+                                    if vec_length > 0
+                                    else 500
+                                )
+                                current_offset += min(estimated, len(element_bytes))
+                        else:
+                            logger.warning(f"Element {i + 1} decode returned no value")
+                            break
+                    except RemainingScaleBytesNotEmptyException as e:
+                        # Exception is OK if we got a value
+                        if (
+                            hasattr(element_obj, "value")
+                            and element_obj.value is not None
+                        ):
+                            decoded_elements.append(element_obj.value)
+                            # Try to get consumed bytes
+                            if hasattr(element_obj, "data") and hasattr(
+                                element_obj.data, "offset"
+                            ):
+                                consumed = element_obj.data.offset
+                                if 0 < consumed <= len(element_bytes):
+                                    current_offset += consumed
+                                else:
+                                    # Try to extract from exception
+                                    exc_msg = str(e)
+                                    if "Current offset:" in exc_msg:
+                                        try:
+                                            consumed = int(
+                                                exc_msg.split("Current offset:")[1]
+                                                .split("/")[0]
+                                                .strip()
+                                            )
+                                            if 0 < consumed <= len(element_bytes):
+                                                current_offset += consumed
+                                            else:
+                                                break
+                                        except Exception:
+                                            break
+                                    else:
+                                        # Estimate
+                                        estimated = (
+                                            len(normalized) // vec_length
+                                            if vec_length > 0
+                                            else 500
+                                        )
+                                        current_offset += min(
+                                            estimated, len(element_bytes)
+                                        )
+                            else:
+                                break
+                        else:
+                            logger.warning(
+                                f"Element {i + 1} decode failed with no value: {e}"
+                            )
+                            break
+                    except Exception as e:
+                        logger.error(f"Element {i + 1} decode failed: {e}")
+                        break
+
+                if decoded_elements and len(decoded_elements) == vec_length:
+                    logger.info(
+                        f"Successfully decoded all {len(decoded_elements)} subnet(s) using Vec element iteration"
+                    )
+                    return decoded_elements
+                elif decoded_elements:
+                    logger.warning(
+                        f"Only decoded {len(decoded_elements)}/{vec_length} elements using Vec iteration"
+                    )
+                    # Don't return partial - let it fall through to manual iteration
+        except Exception as e:
+            logger.debug(
+                f"Vec element iteration failed: {e}, falling back to manual iteration"
+            )
+
+        # Manual iteration approach: decode Vec length, then each SubnetInfo individually
+        logger.debug("Attempting manual iteration for Vec<SubnetInfo>")
+
+        # Read Vec length (compact-encoded)
+        if len(normalized) < 1:
+            logger.error("Not enough data to read Vec length")
+            return []
+
+        vec_length_byte = normalized[0]
+        # Compact encoding: first 2 bits determine format
+        # 00 = single byte (max 63), 01 = 2 bytes, 10 = 4 bytes, 11 = large integer
+        if (vec_length_byte & 0x03) == 0x00:
+            vec_length = vec_length_byte >> 2
+            offset = 1
+        elif (vec_length_byte & 0x03) == 0x01:
+            # 2-byte compact
+            if len(normalized) < 2:
+                logger.error("Not enough data for 2-byte compact length")
+                return []
+            vec_length = ((vec_length_byte >> 2) | (normalized[1] << 6)) & 0x3FFF
+            offset = 2
+        elif (vec_length_byte & 0x03) == 0x02:
+            # 4-byte compact
+            if len(normalized) < 4:
+                logger.error("Not enough data for 4-byte compact length")
+                return []
+            vec_length = (
+                ((vec_length_byte >> 2) & 0x3F)
+                | (normalized[1] << 6)
+                | (normalized[2] << 14)
+                | (normalized[3] << 22)
+            ) & 0x3FFFFFFF
+            offset = 4
+        else:
+            logger.error("Large integer compact encoding not supported for Vec length")
+            return []
+
+        logger.debug(f"Vec length: {vec_length}, starting at offset {offset}")
+
+        decoded_subnets = []
+
+        # Decode each SubnetInfo individually
+        for i in range(vec_length):
+            if offset >= len(normalized):
+                logger.warning(
+                    f"Ran out of data while decoding subnet {i + 1}/{vec_length} at offset {offset}"
+                )
+                break
+
+            subnet_bytes = normalized[offset:]
+            logger.debug(
+                f"Decoding subnet {i + 1}/{vec_length} at offset {offset}, {len(subnet_bytes)} bytes remaining"
+            )
+
+            single_obj = config.create_scale_object("SubnetInfo")
+            exception_raised = None
+            consumed_bytes = 0
+
+            try:
+                single_obj.decode(ScaleBytes(subnet_bytes))
+                # Success - no exception
+            except RemainingScaleBytesNotEmptyException as e:
+                # Expected - SubnetInfo decode might raise this even on success
+                exception_raised = e
+                # Try to extract consumed bytes from exception message in various formats
+                exc_msg = str(e)
+                if "Current offset:" in exc_msg:
+                    try:
+                        # Parse offset from exception: "Decoding <SubnetInfo> - Current offset: 359 / length: 1560"
+                        parts = (
+                            exc_msg.split("Current offset:")[1].split("/")[0].strip()
+                        )
+                        consumed_bytes = int(parts)
+                        logger.debug(
+                            f"Extracted consumed bytes from 'Current offset:' pattern: {consumed_bytes}"
+                        )
+                    except (ValueError, IndexError) as parse_error:
+                        logger.debug(
+                            f"Could not parse offset from 'Current offset:' pattern: {parse_error}"
+                        )
+                elif "needed:" in exc_msg and "/ total:" in exc_msg:
+                    # Handle "Decoding <Bytes> - No more bytes available (needed: X / total: Y)"
+                    # This usually means we ran out of bytes, but check if data.offset gives us a value
+                    try:
+                        if hasattr(single_obj, "data") and hasattr(
+                            single_obj.data, "offset"
+                        ):
+                            # The offset should tell us how many bytes were consumed before the error
+                            potential_offset = single_obj.data.offset
+                            # If offset is reasonable (less than remaining bytes), use it
+                            if 0 < potential_offset <= len(subnet_bytes):
+                                consumed_bytes = potential_offset
+                                logger.debug(
+                                    f"Extracted consumed bytes from data.offset after 'needed/total' exception: {consumed_bytes}"
+                                )
+                    except Exception as offset_error:
+                        logger.debug(f"Could not get offset from data: {offset_error}")
+            except Exception as e:
+                logger.error(f"Failed to decode subnet {i + 1}: {e}")
+                break
+
+            # Extract value even if exception was raised
+            # Check if value exists and is not None
+            has_value = hasattr(single_obj, "value") and single_obj.value is not None
+
+            if has_value:
+                decoded_subnets.append(single_obj.value)
+
+                # Get consumed bytes - try multiple methods
+                if consumed_bytes == 0:
+                    # Try data.offset first
+                    if hasattr(single_obj, "data") and hasattr(
+                        single_obj.data, "offset"
+                    ):
+                        potential_offset = single_obj.data.offset
+                        # Only use if it's reasonable
+                        if 0 < potential_offset <= len(subnet_bytes):
+                            consumed_bytes = potential_offset
+                            logger.debug(
+                                f"Got consumed bytes from data.offset: {consumed_bytes}"
+                            )
+
+                # Advance offset
+                if consumed_bytes > 0:
+                    offset += consumed_bytes
+                    logger.debug(
+                        f"Subnet {i + 1} decoded successfully, consumed {consumed_bytes} bytes, new offset: {offset}"
+                    )
+                else:
+                    # Last resort: estimate based on remaining bytes
+                    if i < vec_length - 1:
+                        # Estimate size based on remaining bytes divided by remaining subnets
+                        remaining_subnets = vec_length - i
+                        estimated_size = len(subnet_bytes) // remaining_subnets
+                        # Use minimum of estimated size or a reasonable maximum (500 bytes)
+                        consumed_bytes = min(estimated_size, 500)
+                        offset += consumed_bytes
+                        logger.warning(
+                            f"Subnet {i + 1} decoded but couldn't determine consumed bytes, using estimate: {consumed_bytes} bytes"
+                        )
+                    else:
+                        logger.debug(
+                            f"Last subnet {i + 1} decoded, no need to advance offset"
+                        )
+            else:
+                # No value extracted - this subnet decoding failed
+                # If we have consumed_bytes from data.offset, we might still want to try skipping forward
+                if consumed_bytes > 0 and consumed_bytes <= len(subnet_bytes):
+                    logger.warning(
+                        f"Subnet {i + 1} decoding failed but got consumed_bytes={consumed_bytes}, advancing anyway"
+                    )
+                    offset += consumed_bytes
+                else:
+                    logger.error(f"No value extracted for subnet {i + 1}")
+                    if exception_raised:
+                        logger.debug(f"Exception was: {exception_raised}")
+                    # Try to estimate and continue if not the last subnet
+                    if i < vec_length - 1:
+                        remaining_subnets = vec_length - i
+                        estimated_size = len(subnet_bytes) // remaining_subnets
+                        estimated_size = min(estimated_size, 500)
+                        logger.warning(
+                            f"Attempting to continue with estimated size: {estimated_size} bytes"
+                        )
+                        offset += estimated_size
+                    else:
+                        break
+
+        if decoded_subnets:
+            # Check if we decoded all expected subnets
+            if len(decoded_subnets) < vec_length:
+                logger.warning(
+                    f"Manual iteration only decoded {len(decoded_subnets)}/{vec_length} subnets. "
+                    "Returning empty list to trigger fallback method."
+                )
+                return []
+            logger.info(
+                f"Successfully decoded {len(decoded_subnets)} subnet(s) using manual iteration"
+            )
+            return decoded_subnets
+        else:
+            logger.error("Manual iteration decoded 0 subnets")
+            return []
+
+    except Exception as e:
+        logger.error(f"Unexpected error decoding Vec<SubnetInfo>: {e}")
+        return []
+
+
+def _manual_decode_vec_subnet_node_info(
+    normalized: bytes, config, vec_length: int
+) -> list[dict]:
+    """
+    Manually decode Vec<SubnetNodeInfo> by iterating through each element.
+
+    This is used as a fallback when the direct Vec decode only returns partial results.
+    """
+    try:
+        # Read Vec length from compact encoding (don't trust the passed vec_length parameter)
+        vec_length_byte = normalized[0]
+        actual_vec_length = vec_length  # Default to passed value
+
+        # Decode actual Vec length from compact encoding
+        if (vec_length_byte & 0x03) == 0x00:
+            actual_vec_length = vec_length_byte >> 2
+            offset = 1
+        elif (vec_length_byte & 0x03) == 0x01:
+            if len(normalized) >= 2:
+                actual_vec_length = (
+                    (vec_length_byte >> 2) | (normalized[1] << 6)
+                ) & 0x3FFF
+                offset = 2
+            else:
+                offset = 2
+        elif (vec_length_byte & 0x03) == 0x02:
+            if len(normalized) >= 4:
+                actual_vec_length = (
+                    ((vec_length_byte >> 2) & 0x3F)
+                    | (normalized[1] << 6)
+                    | (normalized[2] << 14)
+                    | (normalized[3] << 22)
+                ) & 0x3FFFFFFF
+                offset = 4
+            else:
+                offset = 4
+        else:
+            offset = 1
+
+        decoded_nodes = []
+
+        # Decode each SubnetNodeInfo individually using the actual Vec length
+        for i in range(actual_vec_length):
+            if offset >= len(normalized):
+                logger.warning(
+                    f"Ran out of data while decoding node {i + 1}/{actual_vec_length} at offset {offset}"
+                )
+                break
+
+            node_bytes = normalized[offset:]
+
+            single_obj = config.create_scale_object("SubnetNodeInfo")
+            consumed_bytes = 0
+
+            try:
+                single_obj.decode(ScaleBytes(node_bytes))
+                # Success - no exception
+            except RemainingScaleBytesNotEmptyException as e:
+                # Expected - SubnetNodeInfo decode might raise this even on success
+                exc_msg = str(e)
+                # Try to extract consumed bytes from exception message in various formats
+                if "Current offset:" in exc_msg:
+                    try:
+                        # Parse offset from exception: "Decoding <SubnetNodeInfo> - Current offset: 359 / length: 1560"
+                        parts = (
+                            exc_msg.split("Current offset:")[1].split("/")[0].strip()
+                        )
+                        consumed_bytes = int(parts)
+                    except (ValueError, IndexError):
+                        pass
+                elif "needed:" in exc_msg and "/ total:" in exc_msg:
+                    # Handle "Decoding <Bytes> - No more bytes available (needed: X / total: Y)"
+                    # This usually means we ran out of bytes, but check if data.offset gives us a value
+                    try:
+                        if hasattr(single_obj, "data") and hasattr(
+                            single_obj.data, "offset"
+                        ):
+                            potential_offset = single_obj.data.offset
+                            if 0 < potential_offset <= len(node_bytes):
+                                consumed_bytes = potential_offset
+                    except Exception:
+                        pass
+            except Exception as e:
+                logger.error(f"Failed to decode node {i + 1}: {e}")
+                break
+
+            # Extract value even if exception was raised
+            has_value = hasattr(single_obj, "value") and single_obj.value is not None
+
+            if has_value:
+                decoded_nodes.append(single_obj.value)
+
+                # Get consumed bytes - try multiple methods
+                if consumed_bytes == 0:
+                    # Try data.offset first
+                    if hasattr(single_obj, "data") and hasattr(
+                        single_obj.data, "offset"
+                    ):
+                        potential_offset = single_obj.data.offset
+                        # Only use if it's reasonable
+                        if 0 < potential_offset <= len(node_bytes):
+                            consumed_bytes = potential_offset
+
+                # Advance offset
+                if consumed_bytes > 0:
+                    offset += consumed_bytes
+                else:
+                    # Last resort: estimate based on remaining bytes
+                    if i < actual_vec_length - 1:
+                        # Estimate size based on remaining bytes divided by remaining nodes
+                        remaining_nodes = actual_vec_length - i
+                        estimated_size = len(node_bytes) // remaining_nodes
+                        # Use minimum of estimated size or a reasonable maximum (500 bytes)
+                        consumed_bytes = min(estimated_size, 500)
+                        offset += consumed_bytes
+            else:
+                if i < actual_vec_length - 1:
+                    remaining_nodes = actual_vec_length - i
+                    estimated_size = len(node_bytes) // remaining_nodes
+                    estimated_size = min(estimated_size, 500)
+                    offset += estimated_size
+                else:
+                    break
+
+        if decoded_nodes:
+            logger.info(
+                f"Manually decoded {len(decoded_nodes)}/{actual_vec_length} node(s)"
+            )
+            return decoded_nodes
+        else:
+            logger.error("Manual decode decoded 0 nodes")
+            return []
+
+    except Exception as e:
+        logger.error(f"Unexpected error in manual Vec<SubnetNodeInfo> decode: {e}")
+        return []
+
+
+def decode_option_subnet_node_info(data: bytes) -> dict:
+    """
+    Decode Option<SubnetNodeInfo> from SCALE bytes.
+
+    Args:
+        data: SCALE-encoded bytes
+
+    Returns:
+        Decoded SubnetNodeInfo dict or None if not found
+    """
+    normalized = _normalize_scale_input(data)
+    if not normalized:
+        return None
+
+    config = get_rpc_runtime_config()
+
+    # Check first byte to see if Option is Some (0x01) or None (0x00)
+    if len(normalized) == 0:
+        return None
+
+    option_byte = normalized[0]
+    if option_byte == 0x00:
+        # Option::None
+        return None
+    elif option_byte == 0x01:
+        # Option::Some - decode the SubnetNodeInfo directly (skip discriminant)
+        info_bytes = normalized[1:]
+
+        info_obj = config.create_scale_object("SubnetNodeInfo")
+        try:
+            info_obj.decode(ScaleBytes(info_bytes))
+        except RemainingScaleBytesNotEmptyException:
+            # Expected for some registry mismatches; value is still populated
+            pass
+        except Exception as e:
+            logger.error(f"Failed to decode SubnetNodeInfo in Option: {e}")
+            return None
+
+        if hasattr(info_obj, "value") and info_obj.value:
+            return info_obj.value
+
+        return None
+
+    # Unexpected discriminant
+    logger.warning(f"Unknown Option<SubnetNodeInfo> discriminant byte: {option_byte}")
+    return None
+
+
+def decode_vec_subnet_node_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<SubnetNodeInfo> from SCALE bytes.
+
+    This mirrors the more defensive logic used for Vec<SubnetInfo> and
+    tolerates RemainingScaleBytesNotEmptyException by extracting already
+    decoded values from the Vec object.
+
+    Args:
+        data: SCALE-encoded bytes (list of ints or bytes object)
+
+    Returns:
+        List of decoded SubnetNodeInfo dicts
+    """
+    normalized = _normalize_scale_input(data)
+    if not normalized:
+        return []
+
+    config = get_rpc_runtime_config()
+
+    try:
+        vec_obj = config.create_scale_object("Vec<SubnetNodeInfo>")
+
+        exception_occurred = False
+        exception_msg = None
+        try:
+            vec_obj.decode(ScaleBytes(normalized))
+            logger.debug("Vec<SubnetNodeInfo> decoded without exception")
+        except RemainingScaleBytesNotEmptyException as e:
+            # Expected in some cases; values are still populated on the object
+            exception_occurred = True
+            exception_msg = str(e)
+            logger.debug(
+                f"RemainingScaleBytesNotEmptyException during Vec<SubnetNodeInfo> decode: {exception_msg}"
+            )
+        except Exception as e:
+            logger.warning(
+                f"Exception during Vec<SubnetNodeInfo> decode: {e}, trying to extract partial results"
+            )
+            exception_occurred = True
+            exception_msg = str(e)
+
+        decoded_list = None
+
+        # Method 1: direct .value
+        if hasattr(vec_obj, "value") and vec_obj.value is not None:
+            decoded_list = vec_obj.value
+
+        # Method 2: value_list
+        if (
+            (
+                decoded_list is None
+                or (isinstance(decoded_list, list) and len(decoded_list) == 0)
+            )
+            and hasattr(vec_obj, "value_list")
+            and vec_obj.value_list
+        ):
+            decoded_list = vec_obj.value_list
+
+        # Method 3: internal elements attributes
+        if decoded_list is None or (
+            isinstance(decoded_list, list) and len(decoded_list) == 0
+        ):
+            elements = None
+            if hasattr(vec_obj, "_elements"):
+                elements = vec_obj._elements
+            elif hasattr(vec_obj, "elements"):
+                elements = vec_obj.elements
+
+            if elements:
+                try:
+                    decoded_list = [el.value for el in elements]
+                except Exception:
+                    decoded_list = elements
+
+        if decoded_list is None:
+            if exception_occurred:
+                logger.warning(
+                    f"Could not extract SubnetNodeInfo list after Vec decode error: {exception_msg}"
+                )
+            return []
+
+        # Ensure we always return a plain list of dicts
+        result: list[dict] = []
+        for item in decoded_list:
+            if isinstance(item, dict):
+                result.append(item)
+            elif hasattr(item, "value") and isinstance(item.value, dict):
+                result.append(item.value)
+            else:
+                # Fallback: try model_dump if it's a Pydantic-like object
+                try:
+                    dumped = item.model_dump()
+                    if isinstance(dumped, dict):
+                        result.append(dumped)
+                except Exception:
+                    logger.debug(
+                        f"Skipping non-dict Vec<SubnetNodeInfo> element: {item}"
+                    )
+
+        # If we got a partial decode (exception occurred or we have large data but few results),
+        # try manual iteration to decode all elements
+        should_try_manual = False
+        vec_length = len(result)  # Default to what we have
+
+        # Check if we should try manual decode:
+        # 1. Exception occurred during decode, OR
+        # 2. We have significant data (>100 bytes) but only decoded 1-2 items (suggests partial decode)
+        if exception_occurred or (len(normalized) > 100 and len(result) <= 2):
+            should_try_manual = True
+
+            # Try to read actual Vec length from compact encoding
+            try:
+                vec_length_byte = normalized[0]
+                # Compact encoding: first 2 bits determine format
+                if (vec_length_byte & 0x03) == 0x00:
+                    vec_length = vec_length_byte >> 2
+                elif (vec_length_byte & 0x03) == 0x01:
+                    if len(normalized) >= 2:
+                        vec_length = (
+                            (vec_length_byte >> 2) | (normalized[1] << 6)
+                        ) & 0x3FFF
+                elif (vec_length_byte & 0x03) == 0x02:
+                    if len(normalized) >= 4:
+                        vec_length = (
+                            ((vec_length_byte >> 2) & 0x3F)
+                            | (normalized[1] << 6)
+                            | (normalized[2] << 14)
+                            | (normalized[3] << 22)
+                        ) & 0x3FFFFFFF
+            except Exception as e:
+                logger.debug(f"Could not read Vec length: {e}")
+                # Estimate vec_length from data size (rough estimate: ~200-500 bytes per node)
+                estimated_length = max(len(result), len(normalized) // 300)
+                vec_length = min(estimated_length, 100)  # Cap at reasonable limit
+
+        if should_try_manual and vec_length > len(result):
+            manual_result = _manual_decode_vec_subnet_node_info(
+                normalized, config, vec_length
+            )
+            if manual_result and len(manual_result) >= len(result):
+                return manual_result
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to decode Vec<SubnetNodeInfo>: {e}")
+        return []
+
+
+def decode_vec_subnet_node_stake_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<SubnetNodeStakeInfo> from SCALE bytes.
+
+    Args:
+        data: SCALE-encoded bytes
+
+    Returns:
+        List of decoded SubnetNodeStakeInfo dicts
+    """
+    decoded = _decode_scale_object(data, "Vec<SubnetNodeStakeInfo>")
+    return decoded or []
+
+
+def decode_vec_node_stake_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<NodeStakeInfo> from SCALE bytes.
+
+    Validator stake RPCs return NodeStakeInfo, which omits the hotkey field
+    present in legacy SubnetNodeStakeInfo responses.
+    """
+    decoded = _decode_scale_object(data, "Vec<NodeStakeInfo>")
+    return decoded or []
+
+
+def decode_vec_delegate_stake_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<DelegateStakeInfo> from SCALE bytes.
+
+    Args:
+        data: SCALE-encoded bytes
+
+    Returns:
+        List of decoded DelegateStakeInfo dicts
+    """
+    decoded = _decode_scale_object(data, "Vec<DelegateStakeInfo>")
+    return decoded or []
+
+
+def decode_vec_node_delegate_stake_info(data: bytes) -> list[dict]:
+    """
+    Decode Vec<NodeDelegateStakeInfo> from SCALE bytes.
+
+    Args:
+        data: SCALE-encoded bytes
+
+    Returns:
+        List of decoded NodeDelegateStakeInfo dicts
+    """
+    decoded = _decode_scale_object(data, "Vec<NodeDelegateStakeInfo>")
+    return decoded or []