htcli 1.1.0__py3-none-any.whl

src/htcli/models/responses/subnet.py

@@ -0,0 +1,856 @@
+"""
+Subnet-related response models.
+"""
+
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field, field_validator
+from scalecodec.base import RuntimeConfiguration, ScaleBytes
+from substrateinterface.base import load_type_registry_preset
+
+from src.htcli.models.enums.enum_types import KeyType, SubnetState
+
+from .base import BaseResponse
+
+
+class SubnetRegisterResponse(BaseResponse):
+    """Response model for subnet registration."""
+
+    subnet_id: Optional[int] = Field(None, description="Assigned subnet ID")
+    cost_paid: Optional[int] = Field(
+        None, description="Actual cost paid for registration"
+    )
+    owner: Optional[str] = Field(None, description="Subnet owner account")
+    name: Optional[str] = Field(None, description="Registered subnet name")
+
+
+class SubnetData(BaseModel):
+    """Subnet data structure matching Rust SubnetData with validation."""
+
+    id: int = Field(..., description="Subnet ID", ge=0)
+    friendly_id: Optional[int] = Field(None, description="Subnet friendly ID", ge=0)
+    name: bytes = Field(..., description="Subnet name")
+    repo: bytes = Field(..., description="Repository URL")
+    description: bytes = Field(default=b"", description="Subnet description")
+    misc: bytes = Field(default=b"", description="Miscellaneous information")
+    state: SubnetState = Field(..., description="Subnet state")
+    start_epoch: int = Field(..., description="Start epoch", ge=0)
+
+    @field_validator("name", "repo", "description", "misc")
+    def validate_bytes_not_empty(cls, v):
+        """Ensure byte fields are not None."""
+        if v is None:
+            return b""
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "SubnetData":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        # Load type registry
+        type_registry = load_type_registry_preset("substrate-node-template")
+
+        # Create runtime configuration
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        # Decode the data
+        obj = runtime_config.create_scale_object("SubnetData", ScaleBytes(data))
+        obj.decode()
+
+        _missing = object()
+        friendly_id = obj.get("friendly_id", _missing)
+        if friendly_id is _missing:
+            friendly_id = obj["id"]
+
+        return cls(
+            id=obj["id"],
+            friendly_id=friendly_id,
+            name=obj["name"],
+            repo=obj["repo"],
+            description=obj["description"],
+            misc=obj["misc"],
+            state=SubnetState(obj["state"].name),
+            start_epoch=obj["start_epoch"],
+        )
+
+
+class SubnetInfo(BaseModel):
+    """Complete subnet information structure matching Rust SubnetInfo with validation."""
+
+    id: int = Field(..., description="Subnet ID", ge=0)
+    friendly_id: Optional[int] = Field(None, description="Subnet friendly ID", ge=0)
+    name: bytes = Field(..., description="Subnet name")
+    repo: bytes = Field(..., description="Repository URL")
+    description: bytes = Field(default=b"", description="Subnet description")
+    misc: bytes = Field(default=b"", description="Miscellaneous information")
+    state: SubnetState = Field(..., description="Subnet state")
+    start_epoch: int = Field(..., description="Start epoch", ge=0)
+    churn_limit: int = Field(default=0, description="Churn limit", ge=0)
+    churn_limit_multiplier: int = Field(
+        default=1, description="Churn limit multiplier", ge=0
+    )
+    min_stake: int = Field(default=0, description="Minimum stake balance", ge=0)
+    max_stake: int = Field(default=0, description="Maximum stake balance", ge=0)
+    queue_immunity_epochs: int = Field(
+        default=0, description="Queue immunity epochs", ge=0
+    )
+    target_node_registrations_per_epoch: int = Field(
+        default=0, description="Target node registrations per epoch", ge=0
+    )
+    node_registrations_this_epoch: int = Field(
+        default=0, description="Node registrations this epoch", ge=0
+    )
+    subnet_node_queue_epochs: int = Field(
+        default=0, description="Subnet node queue epochs", ge=0
+    )
+    idle_classification_epochs: int = Field(
+        default=0, description="Idle classification epochs", ge=0
+    )
+    included_classification_epochs: int = Field(
+        default=0, description="Included classification epochs", ge=0
+    )
+    delegate_stake_percentage: int = Field(
+        default=0, description="Delegate stake percentage (wei)", ge=0
+    )
+    last_delegate_stake_rewards_update: int = Field(
+        default=0, description="Last delegate stake rewards update epoch", ge=0
+    )
+    node_burn_rate_alpha: int = Field(
+        default=0, description="Node burn rate alpha (wei)", ge=0
+    )
+    current_node_burn_rate: int = Field(
+        default=0, description="Current node burn rate (wei)", ge=0
+    )
+    initial_coldkeys: Optional[dict[str, int]] = Field(
+        None,
+        description="Initial coldkeys and how many nodes each may register",
+    )
+    initial_coldkey_data: Optional[dict[str, int]] = Field(
+        None,
+        description="Initial coldkey data",
+    )
+    max_registered_nodes: int = Field(
+        default=0, description="Maximum registered nodes", ge=0
+    )
+    owner: Optional[str] = Field(None, description="Subnet owner")
+    pending_owner: Optional[str] = Field(None, description="Pending subnet owner")
+    registration_epoch: Optional[int] = Field(
+        None, description="Registration epoch", ge=0
+    )
+    prev_pause_epoch: int = Field(default=0, description="Previous pause epoch", ge=0)
+    key_types: set[KeyType] = Field(
+        default_factory=set, description="Supported key types"
+    )
+    slot_index: Optional[int] = Field(None, description="Slot index", ge=0)
+    slot_assignment: Optional[int] = Field(None, description="Slot assignment", ge=0)
+    subnet_node_min_weight_decrease_reputation_threshold: int = Field(
+        default=0,
+        description="Subnet node min weight decrease reputation threshold",
+        ge=0,
+    )
+    reputation: int = Field(default=0, description="Subnet reputation score", ge=0)
+    min_subnet_node_reputation: int = Field(
+        default=0, description="Minimum subnet node reputation", ge=0
+    )
+    absent_decrease_reputation_factor: int = Field(
+        default=0, description="Absent decrease reputation factor", ge=0
+    )
+    included_increase_reputation_factor: int = Field(
+        default=0, description="Included increase reputation factor", ge=0
+    )
+    below_min_weight_decrease_reputation_factor: int = Field(
+        default=0, description="Below minimum weight decrease factor", ge=0
+    )
+    non_attestor_decrease_reputation_factor: int = Field(
+        default=0, description="Non-attestor decrease reputation factor", ge=0
+    )
+    non_consensus_attestor_decrease_reputation_factor: int = Field(
+        default=0, description="Non-consensus attestor decrease factor", ge=0
+    )
+    validator_absent_subnet_node_reputation_factor: int = Field(
+        default=0, description="Validator absent reputation factor", ge=0
+    )
+    validator_non_consensus_subnet_node_reputation_factor: int = Field(
+        default=0, description="Validator non-consensus reputation factor", ge=0
+    )
+    bootnode_access: set[str] = Field(
+        default_factory=set, description="Bootnode access accounts"
+    )
+    bootnodes: set[bytes] = Field(default_factory=set, description="Bootnode addresses")
+    total_nodes: int = Field(default=0, description="Total number of nodes", ge=0)
+    total_active_nodes: int = Field(default=0, description="Total active nodes", ge=0)
+    total_electable_nodes: int = Field(
+        default=0, description="Total electable nodes", ge=0
+    )
+    current_min_delegate_stake: int = Field(
+        default=0, description="Current minimum delegate stake balance", ge=0
+    )
+    total_subnet_stake: int = Field(
+        default=0, description="Total subnet stake balance", ge=0
+    )
+    total_subnet_delegate_stake_shares: int = Field(
+        default=0, description="Total subnet delegate stake shares", ge=0
+    )
+    total_subnet_delegate_stake_balance: int = Field(
+        default=0, description="Total subnet delegate stake balance", ge=0
+    )
+
+    @field_validator("name", "repo", "description", "misc")
+    def validate_bytes_not_empty(cls, v):
+        """Ensure byte fields are not None."""
+        if v is None:
+            return b""
+        return v
+
+    @field_validator("max_stake")
+    def validate_max_stake(cls, v, info):
+        """Ensure max_stake >= min_stake."""
+        values = info.data if hasattr(info, "data") else {}
+        if "min_stake" in values and v < values["min_stake"]:
+            raise ValueError("max_stake must be greater than or equal to min_stake")
+        return v
+
+    @field_validator("total_active_nodes")
+    def validate_active_nodes(cls, v, info):
+        """Ensure total_active_nodes <= total_nodes."""
+        values = info.data if hasattr(info, "data") else {}
+        if "total_nodes" in values and v > values["total_nodes"]:
+            raise ValueError("total_active_nodes cannot be greater than total_nodes")
+        return v
+
+    @field_validator("total_electable_nodes")
+    def validate_electable_nodes(cls, v, info):
+        """Ensure total_electable_nodes <= total_active_nodes."""
+        values = info.data if hasattr(info, "data") else {}
+        if "total_active_nodes" in values and v > values["total_active_nodes"]:
+            raise ValueError(
+                "total_electable_nodes cannot be greater than total_active_nodes"
+            )
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "SubnetInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        type_registry = load_type_registry_preset("substrate-node-template")
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        obj = runtime_config.create_scale_object("SubnetInfo", ScaleBytes(data))
+        obj.decode()
+
+        def _format_address(value):
+            from src.htcli.utils.blockchain.formatting import to_checksum_address
+
+            if value is None:
+                return None
+            if isinstance(value, str):
+                raw_addr = value if value.startswith("0x") else f"0x{value}"
+                return to_checksum_address(raw_addr)
+            if isinstance(value, (bytes, bytearray)):
+                raw_addr = "0x" + value.hex()
+                return to_checksum_address(raw_addr)
+            if isinstance(value, list):
+                raw_addr = "0x" + bytes(value).hex()
+                return to_checksum_address(raw_addr)
+            return str(value)
+
+        def _parse_initial_coldkeys(raw):
+            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 = _format_address(entry[0])
+                max_regs = entry[1]
+                if addr is not None:
+                    mapping[addr] = max_regs
+            return mapping if mapping else None
+
+        return cls(
+            id=obj["id"],
+            friendly_id=obj.get("friendly_id"),
+            name=obj["name"],
+            repo=obj["repo"],
+            description=obj["description"],
+            misc=obj["misc"],
+            state=SubnetState(obj["state"].name),
+            start_epoch=obj["start_epoch"],
+            churn_limit=obj["churn_limit"],
+            min_stake=obj["min_stake"],
+            max_stake=obj["max_stake"],
+            queue_immunity_epochs=obj["queue_immunity_epochs"],
+            target_node_registrations_per_epoch=obj[
+                "target_node_registrations_per_epoch"
+            ],
+            subnet_node_queue_epochs=obj["subnet_node_queue_epochs"],
+            idle_classification_epochs=obj["idle_classification_epochs"],
+            included_classification_epochs=obj["included_classification_epochs"],
+            delegate_stake_percentage=obj["delegate_stake_percentage"],
+            node_burn_rate_alpha=obj["node_burn_rate_alpha"],
+            initial_coldkeys=_parse_initial_coldkeys(obj.get("initial_coldkeys")),
+            max_registered_nodes=obj["max_registered_nodes"],
+            owner=_format_address(obj["owner"]),
+            pending_owner=_format_address(obj["pending_owner"]),
+            registration_epoch=obj["registration_epoch"],
+            key_types={KeyType(kt.name) for kt in obj["key_types"]},
+            slot_index=obj["slot_index"],
+            reputation=obj["reputation"],
+            min_subnet_node_reputation=obj["min_subnet_node_reputation"],
+            absent_decrease_reputation_factor=obj["absent_decrease_reputation_factor"],
+            included_increase_reputation_factor=obj[
+                "included_increase_reputation_factor"
+            ],
+            below_min_weight_decrease_reputation_factor=obj[
+                "below_min_weight_decrease_reputation_factor"
+            ],
+            non_attestor_decrease_reputation_factor=obj[
+                "non_attestor_decrease_reputation_factor"
+            ],
+            non_consensus_attestor_decrease_reputation_factor=obj[
+                "non_consensus_attestor_decrease_reputation_factor"
+            ],
+            validator_absent_subnet_node_reputation_factor=obj[
+                "validator_absent_subnet_node_reputation_factor"
+            ],
+            validator_non_consensus_subnet_node_reputation_factor=obj[
+                "validator_non_consensus_subnet_node_reputation_factor"
+            ],
+            bootnode_access={_format_address(addr) for addr in obj["bootnode_access"]},
+            bootnodes={bytes(bn) for bn in obj["bootnodes"]},
+            total_nodes=obj["total_nodes"],
+            total_active_nodes=obj["total_active_nodes"],
+            total_electable_nodes=obj["total_electable_nodes"],
+            current_min_delegate_stake=obj["current_min_delegate_stake"],
+        )
+
+
+class SubnetNodeInfo(BaseModel):
+    """Subnet node information structure matching Rust SubnetNodeInfo with validation."""
+
+    subnet_id: int = Field(..., description="Subnet ID", ge=0)
+    subnet_node_id: int = Field(..., description="Subnet node ID", ge=0)
+    coldkey: str = Field(..., description="Coldkey account ID")
+    hotkey: str = Field(..., description="Hotkey account ID")
+    peer_id: bytes = Field(..., description="Peer ID")
+    bootnode_peer_id: bytes = Field(..., description="Bootnode peer ID")
+    client_peer_id: bytes = Field(..., description="Client peer ID")
+    bootnode: Optional[bytes] = Field(None, description="Bootnode address")
+    identity: Optional[dict[str, Any]] = Field(None, description="Identity data")
+    classification: dict[str, Any] = Field(
+        ..., description="Node classification (dict with node_class and start_epoch)"
+    )
+    delegate_reward_rate: int = Field(
+        default=0, description="Delegate reward rate", ge=0, le=1000000000000000000
+    )
+    last_delegate_reward_rate_update: int = Field(
+        default=0, description="Last delegate reward rate update", ge=0
+    )
+    unique: Optional[bytes] = Field(None, description="Unique parameter")
+    non_unique: Optional[bytes] = Field(None, description="Non-unique parameter")
+    stake_balance: int = Field(default=0, description="Stake balance", ge=0)
+    total_node_delegate_stake_shares: int = Field(
+        default=0, description="Total node delegate stake shares", ge=0
+    )
+    node_delegate_stake_balance: int = Field(
+        default=0, description="Node delegate stake balance", ge=0
+    )
+    coldkey_reputation: Optional[dict[str, Any]] = Field(
+        None, description="Reputation data for the coldkey"
+    )
+    subnet_node_reputation: int = Field(
+        default=0, description="Subnet node reputation score", ge=0
+    )
+    node_slot_index: Optional[int] = Field(None, description="Node slot index", ge=0)
+    consecutive_idle_epochs: int = Field(
+        default=0, description="Consecutive idle epochs", ge=0
+    )
+    consecutive_included_epochs: int = Field(
+        default=0, description="Consecutive included epochs", ge=0
+    )
+
+    @field_validator("peer_id", "bootnode_peer_id", "client_peer_id")
+    def validate_peer_ids_not_empty(cls, v):
+        """Allow empty peer IDs (blockchain can have empty peer IDs for some nodes)."""
+        return v if v is not None else b""
+
+    @field_validator("delegate_reward_rate")
+    def validate_delegate_reward_rate(cls, v):
+        """Ensure delegate reward rate is within valid range."""
+        if v < 0 or v > 1000000000000000000:  # 100%
+            raise ValueError("Delegate reward rate must be between 0 and 100%")
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "SubnetNodeInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        type_registry = load_type_registry_preset("substrate-node-template")
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        obj = runtime_config.create_scale_object("SubnetNodeInfo", ScaleBytes(data))
+        obj.decode()
+
+        def _format_address(value: bytes) -> str:
+            from src.htcli.utils.blockchain.formatting import to_checksum_address
+
+            if isinstance(value, str):
+                raw_addr = value if value.startswith("0x") else f"0x{value}"
+                return to_checksum_address(raw_addr)
+            if isinstance(value, (bytes, bytearray)):
+                raw_addr = "0x" + value.hex()
+                return to_checksum_address(raw_addr)
+            raw_addr = "0x" + bytes(value).hex()
+            return to_checksum_address(raw_addr)
+
+        return cls(
+            subnet_id=obj["subnet_id"],
+            subnet_node_id=obj["subnet_node_id"],
+            coldkey=_format_address(obj["coldkey"]),
+            hotkey=_format_address(obj["hotkey"]),
+            peer_id=obj["peer_id"],
+            bootnode_peer_id=obj["bootnode_peer_id"],
+            client_peer_id=obj["client_peer_id"],
+            bootnode=bytes(obj["bootnode"]) if obj["bootnode"] else None,
+            identity=obj.get("identity"),
+            classification=obj["classification"],
+            delegate_reward_rate=obj["delegate_reward_rate"],
+            last_delegate_reward_rate_update=obj["last_delegate_reward_rate_update"],
+            unique=bytes(obj["unique"]) if obj["unique"] else None,
+            non_unique=bytes(obj["non_unique"]) if obj["non_unique"] else None,
+            stake_balance=obj["stake_balance"],
+            node_delegate_stake_balance=obj["node_delegate_stake_balance"],
+            coldkey_reputation=obj.get("coldkey_reputation"),
+            subnet_node_reputation=obj["subnet_node_reputation"],
+        )
+
+
+# ============================================================================
+# ============================================================================
+# OVERWATCH NODE RESPONSE MODELS
+# ============================================================================
+
+
+class OverwatchNodeInfo(BaseModel):
+    """Overwatch node information structure matching Rust OverwatchNodeInfo with validation."""
+
+    overwatch_node_id: int = Field(..., description="Overwatch node ID", ge=0)
+    coldkey: str = Field(..., description="Coldkey account ID")
+    hotkey: str = Field(..., description="Hotkey account ID")
+    peer_ids: list[bytes] = Field(default_factory=list, description="Peer IDs")
+    penalties: int = Field(default=0, description="Penalties", ge=0)
+    reputation: Optional[dict[str, Any]] = Field(None, description="Reputation data")
+
+    @field_validator("peer_ids")
+    def validate_peer_ids(cls, v):
+        """Ensure peer IDs are valid."""
+        if v is None:
+            return []
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "OverwatchNodeInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        # Load type registry
+        type_registry = load_type_registry_preset("substrate-node-template")
+
+        # Create runtime configuration
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        # Decode the data
+        obj = runtime_config.create_scale_object("OverwatchNodeInfo", ScaleBytes(data))
+        obj.decode()
+
+        return cls(
+            overwatch_node_id=obj["overwatch_node_id"],
+            coldkey=obj["coldkey"],
+            hotkey=obj["hotkey"],
+            peer_ids=list(obj["peer_ids"]),
+            penalties=obj["penalties"],
+            reputation=obj["reputation"],
+        )
+
+
+# ============================================================================
+# IDENTITY RESPONSE MODELS
+# ============================================================================
+
+
+class IdentityInfo(BaseModel):
+    """Identity information structure with validation."""
+
+    coldkey: str = Field(..., description="Coldkey account ID")
+    hotkey: str = Field(..., description="Hotkey account ID")
+    name: bytes = Field(..., description="Identity name")
+    url: bytes = Field(default=b"", description="Identity URL")
+    image: bytes = Field(default=b"", description="Identity image URL")
+    description: bytes = Field(default=b"", description="Identity description")
+
+    @field_validator("name", "url", "image", "description")
+    def validate_bytes_not_empty(cls, v):
+        """Ensure byte fields are not None."""
+        if v is None:
+            return b""
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "IdentityInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        # Load type registry
+        type_registry = load_type_registry_preset("substrate-node-template")
+
+        # Create runtime configuration
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        # Decode the data
+        obj = runtime_config.create_scale_object("IdentityInfo", ScaleBytes(data))
+        obj.decode()
+
+        return cls(
+            coldkey=obj["coldkey"],
+            hotkey=obj["hotkey"],
+            name=obj["name"],
+            url=obj["url"],
+            image=obj["image"],
+            description=obj["description"],
+        )
+
+
+# ============================================================================
+# STAKE RESPONSE MODELS
+# ============================================================================
+
+
+class StakeInfo(BaseModel):
+    """Stake information structure with validation."""
+
+    account_id: str = Field(..., description="Account ID")
+    subnet_id: int = Field(..., description="Subnet ID", ge=0)
+    stake_amount: int = Field(..., description="Stake amount", ge=0)
+    delegate_stake: int = Field(default=0, description="Delegate stake amount", ge=0)
+    unbonding: int = Field(default=0, description="Unbonding amount", ge=0)
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "StakeInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        # Load type registry
+        type_registry = load_type_registry_preset("substrate-node-template")
+
+        # Create runtime configuration
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        # Decode the data
+        obj = runtime_config.create_scale_object("StakeInfo", ScaleBytes(data))
+        obj.decode()
+
+        return cls(
+            account_id=obj["account_id"],
+            subnet_id=obj["subnet_id"],
+            stake_amount=obj["stake_amount"],
+            delegate_stake=obj["delegate_stake"],
+            unbonding=obj["unbonding"],
+        )
+
+
+# ============================================================================
+# NETWORK RESPONSE MODELS
+# ============================================================================
+
+
+class NetworkInfo(BaseModel):
+    """Network information structure with validation."""
+
+    total_subnets: int = Field(..., description="Total number of subnets", ge=0)
+    total_nodes: int = Field(..., description="Total number of nodes", ge=0)
+    total_overwatch_nodes: int = Field(
+        ..., description="Total number of overwatch nodes", ge=0
+    )
+    current_epoch: int = Field(..., description="Current epoch", ge=0)
+    registration_cost: int = Field(..., description="Current registration cost", ge=0)
+    network_state: str = Field(..., description="Network state")
+
+    @field_validator("network_state")
+    def validate_network_state(cls, v):
+        """Ensure network state is valid."""
+        valid_states = ["Active", "Paused"]
+        if v not in valid_states:
+            raise ValueError(f"Network state must be one of {valid_states}")
+        return v
+
+    @classmethod
+    def from_scale_bytes(cls, data: bytes) -> "NetworkInfo":
+        """Decode from SCALE bytes using scalecodec."""
+        if not ScaleBytes:
+            raise ImportError("scalecodec is required for decoding")
+
+        # Load type registry
+        type_registry = load_type_registry_preset("substrate-node-template")
+
+        # Create runtime configuration
+        runtime_config = RuntimeConfiguration()
+        runtime_config.update_type_registry(type_registry)
+
+        # Decode the data
+        obj = runtime_config.create_scale_object("NetworkInfo", ScaleBytes(data))
+        obj.decode()
+
+        return cls(
+            total_subnets=obj["total_subnets"],
+            total_nodes=obj["total_nodes"],
+            total_overwatch_nodes=obj["total_overwatch_nodes"],
+            current_epoch=obj["current_epoch"],
+            registration_cost=obj["registration_cost"],
+            network_state=obj["network_state"],
+        )
+
+
+class SubnetNodeStakeInfo(BaseModel):
+    """Response model for subnet node stake information."""
+
+    subnet_id: Optional[int] = Field(None, description="Subnet ID")
+    subnet_node_id: Optional[int] = Field(None, description="Subnet node ID")
+    hotkey: str = Field(..., description="Hotkey address")
+    balance: int = Field(..., description="Stake balance")
+
+
+class NodeStakeInfo(BaseModel):
+    """Response model for validator node stake information."""
+
+    subnet_id: Optional[int] = Field(None, description="Subnet ID")
+    subnet_node_id: Optional[int] = Field(None, description="Subnet node ID")
+    balance: int = Field(..., description="Stake balance")
+
+
+class DelegateStakeInfo(BaseModel):
+    """Response model for delegate stake information."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    shares: int = Field(..., description="Delegate stake shares")
+    balance: int = Field(..., description="Delegate stake balance")
+
+
+class NodeDelegateStakeInfo(BaseModel):
+    """Response model for node delegate stake information."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    subnet_node_id: int = Field(..., description="Subnet node ID")
+    shares: int = Field(..., description="Node delegate stake shares")
+    balance: int = Field(..., description="Node delegate stake balance")
+
+
+class AllSubnetBootnodes(BaseModel):
+    """Response model for all subnet bootnodes."""
+
+    bootnodes: list[str] = Field(..., description="Official bootnodes")
+    node_bootnodes: list[str] = Field(..., description="Node bootnodes")
+
+
+class OverwatchCommitInfo(BaseModel):
+    """Response model for overwatch commit information."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    commit_hash: str = Field(..., description="Commit hash")
+
+
+class OverwatchRevealInfo(BaseModel):
+    """Response model for overwatch reveal information."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    reveal_value: int = Field(..., description="Reveal value")
+
+
+class SubnetInfoResponse(BaseModel):
+    """Response model for subnet information."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Subnet information")
+
+
+class SubnetNodeInfoResponse(BaseModel):
+    """Response wrapper for subnet node info RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Subnet node information")
+
+
+class ColdkeySubnetNodesResponse(BaseModel):
+    """Response wrapper for coldkey subnet nodes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Coldkey subnet nodes information")
+
+
+class ValidatorSubnetNodesResponse(BaseModel):
+    """Response wrapper for validator subnet nodes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Validator subnet nodes information")
+
+
+class ColdkeyStakesResponse(BaseModel):
+    """Response wrapper for coldkey stakes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Coldkey stakes information")
+
+
+class ValidatorStakesResponse(BaseModel):
+    """Response wrapper for validator stakes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Validator stakes information")
+
+
+class DelegateStakesResponse(BaseModel):
+    """Response wrapper for delegate stakes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Delegate stakes information")
+
+
+class NodeDelegateStakesResponse(BaseModel):
+    """Response wrapper for node delegate stakes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Node delegate stakes information")
+
+
+class BootnodesResponse(BaseModel):
+    """Response wrapper for bootnodes RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Bootnodes information")
+
+
+class ProofOfStakeResponse(BaseModel):
+    """Response wrapper for proof of stake RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Proof of stake information")
+
+
+class OverwatchCommitsResponse(BaseModel):
+    """Response wrapper for overwatch commits RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Overwatch commits information")
+
+
+class OverwatchRevealsResponse(BaseModel):
+    """Response wrapper for overwatch reveals RPC calls."""
+
+    success: bool = Field(..., description="Operation success status")
+    message: str = Field(..., description="Response message")
+    data: Optional[Any] = Field(None, description="Overwatch reveals information")
+
+
+class SubnetPauseResponse(BaseModel):
+    """Response model for subnet pause operations."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    success: bool = Field(..., description="Pause operation success")
+    message: str = Field(..., description="Operation message")
+    transaction_hash: Optional[str] = Field(None, description="Transaction hash")
+    block_hash: Optional[str] = Field(
+        None, description="Block hash where transaction was included"
+    )
+    block_number: Optional[int] = Field(
+        None, description="Block number where transaction was included"
+    )
+
+
+class SubnetUnpauseResponse(BaseModel):
+    """Response model for subnet unpause operations."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    success: bool = Field(..., description="Unpause operation success")
+    message: str = Field(..., description="Operation message")
+    transaction_hash: Optional[str] = Field(None, description="Transaction hash")
+    block_hash: Optional[str] = Field(
+        None, description="Block hash where transaction was included"
+    )
+    block_number: Optional[int] = Field(
+        None, description="Block number where transaction was included"
+    )
+
+
+class SubnetOwnershipTransferResponse(BaseModel):
+    """Response model for subnet ownership transfer."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    new_owner: str = Field(..., description="New owner address")
+    success: bool = Field(..., description="Transfer success status")
+    message: str = Field(..., description="Transfer message")
+    transaction_hash: Optional[str] = Field(None, description="Transaction hash")
+    block_hash: Optional[str] = Field(
+        None, description="Block hash where transaction was included"
+    )
+    block_number: Optional[int] = Field(
+        None, description="Block number where transaction was included"
+    )
+
+
+class SubnetOwnerUpdateResponse(BaseModel):
+    """Response model for subnet owner updates."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    old_owner: str = Field(..., description="Previous owner address")
+    new_owner: str = Field(..., description="New owner address")
+    success: bool = Field(..., description="Update success status")
+    message: str = Field(..., description="Update message")
+    transaction_hash: Optional[str] = Field(None, description="Transaction hash")
+    block_hash: Optional[str] = Field(
+        None, description="Block hash where transaction was included"
+    )
+    block_number: Optional[int] = Field(
+        None, description="Block number where transaction was included"
+    )
+
+
+class DelegateStakeIncreaseResponse(BaseModel):
+    """Response model for delegate stake increase."""
+
+    subnet_id: int = Field(..., description="Subnet ID")
+    node_hotkey: str = Field(..., description="Node hotkey")
+    stake_amount: str = Field(..., description="Stake amount")
+    success: bool = Field(..., description="Stake increase success")
+    message: str = Field(..., description="Operation message")
+    transaction_hash: Optional[str] = Field(None, description="Transaction hash")
+    block_hash: Optional[str] = Field(
+        None, description="Block hash where transaction was included"
+    )
+    block_number: Optional[int] = Field(
+        None, description="Block number where transaction was included"
+    )