htcli 1.1.0__py3-none-any.whl

src/htcli/client/extrinsics/subnet.py

@@ -0,0 +1,2218 @@
+"""
+Subnet management extrinsics for HTCLI.
+"""
+
+import ipaddress
+from typing import Any, Optional
+
+import base58
+from substrateinterface import Keypair, SubstrateInterface
+from substrateinterface.exceptions import SubstrateRequestException
+
+from ...models.enums.enum_types import KeyType
+from ...models.requests.subnet import (
+    SubnetActivateRequest,
+    SubnetConfigUpdateRequest,
+    SubnetOwnershipAcceptRequest,
+    SubnetOwnershipTransferRequest,
+    SubnetRegisterRequest,
+    SubnetRemoveRequest,
+    SubnetUpdateRequest,
+)
+from ...models.responses.subnet import SubnetInfo, SubnetRegisterResponse
+from ...utils.blockchain.patches import patch_btreemap_accountid_u32_encoder
+from ...utils.blockchain.peer_id import encode_peer_id
+from ...utils.blockchain.validation import validate_address
+from ...utils.logging import get_logger
+from .base import BaseExtrinsicClient
+
+
+# Simple response wrapper for methods that don't have specific response models
+class SimpleExtrinsicResponse:
+    """Simple wrapper for extrinsic responses."""
+
+    def __init__(self, response_dict: dict):
+        self.success = response_dict.get("success", False)
+        self.error = response_dict.get("error")
+        self.transaction_hash = response_dict.get("extrinsic_hash")
+        self.block_number = response_dict.get("block_number")
+        self.block_hash = response_dict.get("block_hash")
+        self.message = response_dict.get("message")
+
+
+logger = get_logger(__name__)
+
+
+def _encode_unsigned_varint(value: int) -> bytes:
+    if value < 0:
+        raise ValueError("varint value cannot be negative")
+
+    encoded = bytearray()
+    while value >= 0x80:
+        encoded.append((value & 0x7F) | 0x80)
+        value >>= 7
+    encoded.append(value)
+    return bytes(encoded)
+
+
+def _encode_multiaddr(multiaddr: str) -> bytes:
+    """Encode a supported multiaddr string into libp2p multiaddr bytes."""
+    protocols = {
+        "ip4": 4,
+        "tcp": 6,
+        "udp": 273,
+        "ip6": 41,
+        "dns": 53,
+        "dns4": 54,
+        "dns6": 55,
+        "dnsaddr": 56,
+        "p2p": 421,
+    }
+    parts = [part for part in multiaddr.split("/") if part]
+    encoded = bytearray()
+    index = 0
+
+    while index < len(parts):
+        proto = parts[index].lower()
+        if proto not in protocols:
+            raise ValueError(f"Unsupported multiaddr protocol: {proto}")
+        if index + 1 >= len(parts):
+            raise ValueError(f"Missing value for multiaddr protocol: {proto}")
+
+        value = parts[index + 1]
+        encoded += _encode_unsigned_varint(protocols[proto])
+
+        if proto == "ip4":
+            encoded += ipaddress.IPv4Address(value).packed
+        elif proto == "ip6":
+            encoded += ipaddress.IPv6Address(value).packed
+        elif proto in {"tcp", "udp"}:
+            port = int(value)
+            if not 0 <= port <= 65535:
+                raise ValueError(f"Invalid {proto} port: {port}")
+            encoded += port.to_bytes(2, byteorder="big", signed=False)
+        elif proto == "p2p":
+            peer_bytes = base58.b58decode(value)
+            encoded += _encode_unsigned_varint(len(peer_bytes))
+            encoded += peer_bytes
+        else:
+            value_bytes = value.encode("utf-8")
+            encoded += _encode_unsigned_varint(len(value_bytes))
+            encoded += value_bytes
+
+        index += 2
+
+    return bytes(encoded)
+
+
+class SubnetExtrinsics(BaseExtrinsicClient):
+    """Client for subnet-related extrinsics."""
+
+    def __init__(self, substrate: Optional[SubstrateInterface] = None):
+        """Initialize the subnet client."""
+        super().__init__(substrate)
+
+    # ============================================================================
+    # SUBNET REGISTRATION
+    # ============================================================================
+
+    def register_subnet(
+        self, request: SubnetRegisterRequest, keypair: Keypair
+    ) -> SubnetRegisterResponse:
+        """
+        Register a new subnet on the network.
+
+        Args:
+            request: Subnet registration request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            SubnetRegisterResponse with registration result
+        """
+        try:
+            logger.info(f"Registering subnet: {request.name}")
+
+            # Validate inputs
+            self._validate_registration_request(request)
+
+            # Get current registration cost
+            current_cost = self._get_current_registration_cost()
+            logger.info(f"Current registration cost: {current_cost}")
+
+            # Ensure max_cost covers the current cost
+            if request.max_cost < current_cost:
+                return SubnetRegisterResponse(
+                    success=False,
+                    error=f"Max cost {request.max_cost} is less than current cost {current_cost}",
+                )
+
+            # Prepare subnet data for the extrinsic
+            subnet_data = self._prepare_subnet_data(request)
+
+            # Compose the extrinsic call
+            # Note: register_subnet does NOT take a hotkey parameter
+            # The owner is derived from the origin (signer)
+            logger.info("Submitting subnet registration extrinsic...")
+            with patch_btreemap_accountid_u32_encoder():
+                call = self.substrate.compose_call(
+                    call_module="Network",
+                    call_function="register_subnet",
+                    call_params={
+                        "max_cost": request.max_cost,
+                        "subnet_data": subnet_data,
+                    },
+                )
+
+                # Submit the extrinsic using base class method with retry logic
+                result = self._submit_extrinsic(call, keypair)
+
+            if result["success"]:
+                # Debug: print result keys
+                logger.info(f"Registration result keys: {result.keys()}")
+                logger.info(f"Events in result: {len(result.get('events', []))}")
+
+                # Extract event data
+                event_data = self._extract_registration_event_from_result(result)
+                logger.info(f"Extracted event data: {event_data}")
+
+                return SubnetRegisterResponse(
+                    success=True,
+                    subnet_id=event_data.get("subnet_id"),
+                    transaction_hash=result.get("extrinsic_hash"),
+                    block_hash=result.get("block_hash"),
+                    cost_paid=current_cost,
+                    owner=event_data.get("owner"),
+                    name=event_data.get("name"),
+                    block_number=result.get("block_number"),
+                    epoch=self._get_current_epoch(),
+                )
+            else:
+                error_msg = result.get("error", "Unknown error")
+                return SubnetRegisterResponse(success=False, error=error_msg)
+
+        except SubstrateRequestException as e:
+            logger.error(f"Substrate request error: {e}")
+            logger.debug(
+                f"SubstrateRequestException details - type: {type(e)}, message: {str(e)}"
+            )
+            return SubnetRegisterResponse(
+                success=False, error=f"Network error: {str(e)}"
+            )
+        except Exception as e:
+            logger.error(f"Unexpected error during subnet registration: {e}")
+            logger.debug(
+                f"Exception details - type: {type(e)}, message: {str(e)}", exc_info=True
+            )
+            return SubnetRegisterResponse(
+                success=False, error=f"Unexpected error: {str(e)}"
+            )
+
+    # ============================================================================
+    # SUBNET ACTIVATION/DEACTIVATION
+    # ============================================================================
+
+    def activate_subnet(
+        self, request: SubnetActivateRequest, keypair: Keypair
+    ) -> SimpleExtrinsicResponse:
+        """
+        Activate a subnet.
+
+        This extrinsic can result in two different outcomes:
+        1. SubnetActivated event - subnet successfully activated
+        2. SubnetDeactivated event - subnet was removed (failed to meet activation criteria)
+
+        Args:
+            request: Subnet activation request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            SimpleExtrinsicResponse with operation result including actual outcome
+        """
+        try:
+            logger.info(f"Activating subnet: {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="activate_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                events = response.get("events", [])
+
+                # Check for SubnetActivated event (success case)
+                activated_event = self._extract_event_by_type(
+                    events, "Network", "SubnetActivated"
+                )
+                if activated_event:
+                    response["message"] = (
+                        f"Subnet {request.subnet_id} activated successfully"
+                    )
+                    response["actual_result"] = "activated"
+                    return SimpleExtrinsicResponse(response)
+
+                # Check for SubnetDeactivated event (removal case)
+                deactivated_event = self._extract_event_by_type(
+                    events, "Network", "SubnetDeactivated"
+                )
+                if deactivated_event:
+                    # Extract removal reason from event attributes
+                    reason = self._extract_attribute_value(
+                        deactivated_event, 1, "Unknown"
+                    )
+                    reason_name = self._get_removal_reason_name(reason)
+                    reason_message = self._get_subnet_removal_reason_message(
+                        reason_name
+                    )
+
+                    # Mark as not successful since subnet was removed, not activated
+                    response["success"] = False
+                    response["actual_result"] = "removed"
+                    response["removal_reason"] = reason_name
+                    response["message"] = (
+                        f"Subnet {request.subnet_id} was removed: {reason_message}"
+                    )
+                    response["error"] = f"SubnetDeactivated: {reason_message}"
+
+                    logger.warning(
+                        f"Subnet {request.subnet_id} was removed instead of activated. "
+                        f"Reason: {reason_name}"
+                    )
+                    return SimpleExtrinsicResponse(response)
+
+                # Fallback: Transaction succeeded but we couldn't identify the outcome from events
+                # This shouldn't happen normally, but handle it gracefully
+                response["message"] = f"Subnet {request.subnet_id} activation completed"
+                response["actual_result"] = "unknown"
+                logger.warning(
+                    f"Subnet {request.subnet_id} activation completed but could not "
+                    "determine actual outcome from events"
+                )
+
+            return SimpleExtrinsicResponse(response)
+
+        except Exception as e:
+            logger.error(f"Error activating subnet: {e}")
+            return SimpleExtrinsicResponse({"success": False, "error": str(e)})
+
+    def _get_removal_reason_name(self, reason: Any) -> str:
+        """
+        Extract the removal reason name from event attribute.
+
+        The reason can be a string, dict with 'type' key, or other format.
+        """
+        if isinstance(reason, str):
+            return reason
+        if isinstance(reason, dict):
+            # Handle enum format: {'type': 'EnactmentPeriod'} or {'__variant__': 'EnactmentPeriod'}
+            return (
+                reason.get("type")
+                or reason.get("__variant__")
+                or reason.get("name", str(reason))
+            )
+        return str(reason)
+
+    def _get_subnet_removal_reason_message(self, reason: str) -> str:
+        """
+        Convert SubnetRemovalReason enum to user-friendly message.
+
+        Args:
+            reason: The removal reason enum variant name
+
+        Returns:
+            User-friendly explanation of the removal reason
+        """
+        REASONS = {
+            "MinReputation": "Minimum reputation requirements not met",
+            "MinSubnetNodes": "Minimum node count not met - need more nodes registered",
+            "MinSubnetDelegateStake": "Minimum delegate stake not met - need more stake delegated to subnet",
+            "Council": "Removed by governance council",
+            "EnactmentPeriod": "Enactment period expired without meeting activation requirements",
+            "MaxSubnets": "Maximum subnet limit reached on the network",
+            "Owner": "Deactivated by subnet owner",
+            "PauseExpired": "Pause period expired",
+        }
+        return REASONS.get(reason, f"Removed: {reason}")
+
+    def remove_subnet(
+        self, request: SubnetRemoveRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove a subnet.
+
+        Args:
+            request: Subnet removal request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Removing subnet: {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_deactivate_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Subnet {request.subnet_id} removed successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing subnet: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET PAUSE/UNPAUSE
+    # ============================================================================
+
+    def owner_pause_subnet(
+        self, request: SubnetActivateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Pause a subnet (owner only).
+
+        Args:
+            request: Subnet pause request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Pausing subnet: {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_pause_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = f"Subnet {request.subnet_id} paused successfully"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error pausing subnet: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_unpause_subnet(
+        self, request: SubnetActivateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Unpause a subnet (owner only).
+
+        Args:
+            request: Subnet unpause request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Unpausing subnet: {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_unpause_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} unpaused successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error unpausing subnet: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_deactivate_subnet(
+        self, request: SubnetActivateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Deactivate a subnet (owner only).
+
+        Args:
+            request: Subnet deactivation request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Deactivating subnet: {request.subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_deactivate_subnet",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} deactivated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error deactivating subnet: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET METADATA UPDATES
+    # ============================================================================
+
+    def owner_update_name(
+        self, request: SubnetUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet name (owner only).
+
+        Args:
+            request: Subnet name update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} name")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_name",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "value": request.value.encode("utf-8"),
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} name updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet name: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_repo(
+        self, request: SubnetUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet repository URL (owner only).
+
+        Args:
+            request: Subnet repo update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} repository")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_repo",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "value": request.value.encode("utf-8"),
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} repository updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet repository: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_description(
+        self, request: SubnetUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet description (owner only).
+
+        Args:
+            request: Subnet description update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} description")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_description",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "value": request.value.encode("utf-8"),
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} description updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet description: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_misc(
+        self, request: SubnetUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet miscellaneous info (owner only).
+
+        Args:
+            request: Subnet misc update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} misc info")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_misc",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "value": request.value.encode("utf-8"),
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} misc info updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet misc info: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET CONFIGURATION UPDATES
+    # ============================================================================
+
+    def owner_update_parameters(
+        self,
+        subnet_id: int,
+        *,
+        new_name: Optional[str] = None,
+        new_repo: Optional[str] = None,
+        target_node_registrations: Optional[int] = None,
+        node_burn_rate_alpha: Optional[int] = None,
+        queue_immunity_epochs: Optional[int] = None,
+        min_weight_decrease_threshold: Optional[int] = None,
+        min_node_reputation: Optional[int] = None,
+        absent_reputation_penalty: Optional[int] = None,
+        included_reputation_boost: Optional[int] = None,
+        below_min_weight_penalty: Optional[int] = None,
+        non_attestor_penalty: Optional[int] = None,
+        validator_absent_penalty: Optional[int] = None,
+        validator_non_consensus_penalty: Optional[int] = None,
+        non_consensus_attestor_penalty: Optional[int] = None,
+        keypair: Keypair,
+    ) -> list[tuple[str, dict[str, Any]]]:
+        """
+        Perform one or more owner subnet parameter updates in sequence.
+
+        Returns a list of (field_name, result_dict) tuples.
+        """
+        results: list[tuple[str, dict[str, Any]]] = []
+
+        # Metadata updates
+        if new_name is not None:
+            try:
+                request = SubnetUpdateRequest(subnet_id=subnet_id, value=new_name)
+                result = self.owner_update_name(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet name: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("name", result))
+
+        if new_repo is not None:
+            try:
+                request = SubnetUpdateRequest(subnet_id=subnet_id, value=new_repo)
+                result = self.owner_update_repo(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating subnet repo: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("repository", result))
+
+        # Config updates
+        if target_node_registrations is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=target_node_registrations
+                )
+                result = self.owner_update_target_node_registrations_per_epoch(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating target node registrations per epoch: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("target_node_registrations", result))
+
+        if node_burn_rate_alpha is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=node_burn_rate_alpha
+                )
+                result = self.owner_update_node_burn_rate_alpha(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating node burn rate alpha: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("node_burn_rate_alpha", result))
+
+        if queue_immunity_epochs is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=queue_immunity_epochs
+                )
+                result = self.owner_update_queue_immunity_epochs(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating queue immunity epochs: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("queue_immunity_epochs", result))
+
+        if min_weight_decrease_threshold is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=min_weight_decrease_threshold
+                )
+                result = self.owner_update_subnet_node_min_weight_decrease_reputation_threshold(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(
+                    f"Error updating min weight decrease reputation threshold: {e}"
+                )
+                result = {"success": False, "error": str(e)}
+            results.append(("min_weight_decrease_threshold", result))
+
+        if min_node_reputation is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=min_node_reputation
+                )
+                result = self.owner_update_min_subnet_node_reputation(request, keypair)
+            except Exception as e:
+                logger.error(f"Error updating min node reputation: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("min_node_reputation", result))
+
+        if absent_reputation_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=absent_reputation_penalty
+                )
+                result = self.owner_update_absent_decrease_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating absent reputation penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("absent_reputation_penalty", result))
+
+        if included_reputation_boost is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=included_reputation_boost
+                )
+                result = self.owner_update_included_increase_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating included reputation boost: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("included_reputation_boost", result))
+
+        if below_min_weight_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=below_min_weight_penalty
+                )
+                result = self.owner_update_below_min_weight_decrease_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating below-min weight penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("below_min_weight_penalty", result))
+
+        if non_attestor_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=non_attestor_penalty
+                )
+                result = self.owner_update_non_attestor_decrease_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating non-attestor penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("non_attestor_penalty", result))
+
+        if validator_absent_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=validator_absent_penalty
+                )
+                result = self.owner_update_validator_absent_decrease_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating validator absent penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("validator_absent_penalty", result))
+
+        if validator_non_consensus_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=validator_non_consensus_penalty
+                )
+                result = self.owner_update_validator_non_consensus_decrease_reputation_factor(
+                    request, keypair
+                )
+            except Exception as e:
+                logger.error(f"Error updating validator non-consensus penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("validator_non_consensus_penalty", result))
+
+        if non_consensus_attestor_penalty is not None:
+            try:
+                request = SubnetConfigUpdateRequest(
+                    subnet_id=subnet_id, value=non_consensus_attestor_penalty
+                )
+                result = (
+                    self.owner_update_non_consensus_attestor_decrease_reputation_factor(
+                        request, keypair
+                    )
+                )
+            except Exception as e:
+                logger.error(f"Error updating non-consensus attestor penalty: {e}")
+                result = {"success": False, "error": str(e)}
+            results.append(("non_consensus_attestor_penalty", result))
+
+        return results
+
+    def owner_update_churn_limit(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet churn limit (owner only).
+
+        Args:
+            request: Subnet churn limit update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} churn limit")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_churn_limit",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} churn limit updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet churn limit: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_registration_queue_epochs(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet registration queue epochs (owner only).
+
+        Args:
+            request: Subnet queue epochs update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} registration queue epochs"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_registration_queue_epochs",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} registration queue epochs updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet registration queue epochs: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_target_node_registrations_per_epoch(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update target node registrations per epoch (owner only).
+
+        Args:
+            request: Target node registrations update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_target_node_registrations_per_epoch",
+            success_message=(
+                "Subnet {subnet_id} target node registrations per epoch updated successfully"
+            ),
+        )
+
+    def owner_update_activation_grace_epochs(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet activation grace epochs (owner only).
+
+        Args:
+            request: Subnet grace epochs update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} activation grace epochs")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_activation_grace_epochs",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} activation grace epochs updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet activation grace epochs: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_idle_classification_epochs(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet idle classification epochs (owner only).
+
+        Args:
+            request: Subnet idle epochs update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} idle classification epochs"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_idle_classification_epochs",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} idle classification epochs updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet idle classification epochs: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_included_classification_epochs(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet included classification epochs (owner only).
+
+        Args:
+            request: Subnet included epochs update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} included classification epochs"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_included_classification_epochs",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} included classification epochs updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet included classification epochs: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_queue_immunity_epochs(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update queue immunity epochs (owner only).
+
+        Args:
+            request: Queue immunity epochs update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_queue_immunity_epochs",
+            success_message=(
+                "Subnet {subnet_id} queue immunity epochs updated successfully"
+            ),
+        )
+
+    def owner_update_max_node_penalties(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet max node penalties (owner only).
+
+        Args:
+            request: Subnet max penalties update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} max node penalties")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_max_node_penalties",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} max node penalties updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet max node penalties: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET ACCESS CONTROL UPDATES
+    # ============================================================================
+
+    def owner_add_initial_coldkeys(
+        self, subnet_id: int, coldkeys: list[str], keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Add initial coldkeys to subnet (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            coldkeys: list of coldkey account IDs to add
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Adding initial coldkeys to subnet {subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_add_initial_coldkeys",
+                call_params={"subnet_id": subnet_id, "coldkeys": coldkeys},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} initial coldkeys added successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error adding initial coldkeys: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_remove_initial_coldkeys(
+        self, subnet_id: int, coldkeys: list[str], keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove initial coldkeys from subnet (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            coldkeys: list of coldkey account IDs to remove
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Removing initial coldkeys from subnet {subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_remove_initial_coldkeys",
+                call_params={"subnet_id": subnet_id, "coldkeys": coldkeys},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} initial coldkeys removed successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing initial coldkeys: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_key_types(
+        self, subnet_id: int, key_types: list[KeyType], keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet key types (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            key_types: list of key types to update
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating key types for subnet {subnet_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_key_types",
+                call_params={
+                    "subnet_id": subnet_id,
+                    "key_types": [kt.value for kt in key_types],
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} key types updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating key types: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET NODE MANAGEMENT
+    # ============================================================================
+
+    def owner_remove_subnet_node(
+        self, subnet_id: int, subnet_node_id: int, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove a subnet node (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_node_id: The subnet node ID to remove
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Removing subnet {subnet_id} node {subnet_node_id}")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_remove_subnet_node",
+                call_params={"subnet_id": subnet_id, "subnet_node_id": subnet_node_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} node {subnet_node_id} removed successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing subnet node: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET STAKE UPDATES
+    # ============================================================================
+
+    def owner_update_min_stake(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet minimum stake (owner only).
+
+        Args:
+            request: Subnet min stake update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} min stake")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_min_stake",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} min stake updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet min stake: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_max_stake(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet maximum stake (owner only).
+
+        Args:
+            request: Subnet max stake update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} max stake")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_max_stake",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} max stake updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet max stake: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_delegate_stake_percentage(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet delegate stake percentage (owner only).
+
+        Args:
+            request: Subnet delegate stake percentage update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Updating subnet {request.subnet_id} delegate stake percentage"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_delegate_stake_percentage",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} delegate stake percentage updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet delegate stake percentage: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_max_registered_nodes(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update subnet max registered nodes (owner only).
+
+        Args:
+            request: Subnet max registered nodes update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {request.subnet_id} max registered nodes")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_update_max_registered_nodes",
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} max registered nodes updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating subnet max registered nodes: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_update_node_burn_rate_alpha(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update node burn rate alpha (owner only).
+
+        Args:
+            request: Node burn rate alpha update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_node_burn_rate_alpha",
+            success_message=(
+                "Subnet {subnet_id} node burn rate alpha updated successfully"
+            ),
+        )
+
+    def owner_update_subnet_node_min_weight_decrease_reputation_threshold(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update minimum weight decrease reputation threshold (owner only).
+
+        Args:
+            request: Min weight decrease reputation threshold update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function=(
+                "owner_update_subnet_node_min_weight_decrease_reputation_threshold"
+            ),
+            success_message=(
+                "Subnet {subnet_id} min weight decrease reputation threshold updated successfully"
+            ),
+        )
+
+    def owner_update_min_subnet_node_reputation(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update minimum subnet node reputation (owner only).
+
+        Args:
+            request: Minimum subnet node reputation update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_min_subnet_node_reputation",
+            success_message=(
+                "Subnet {subnet_id} minimum node reputation updated successfully"
+            ),
+        )
+
+    def owner_update_absent_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update absent decrease reputation factor (owner only).
+
+        Args:
+            request: Absent decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_absent_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} absent decrease reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_included_increase_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update included increase reputation factor (owner only).
+
+        Args:
+            request: Included increase reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_included_increase_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} included increase reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_below_min_weight_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update below-min weight decrease reputation factor (owner only).
+
+        Args:
+            request: Below-min weight decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_below_min_weight_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} below-min weight decrease reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_non_attestor_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update non-attestor decrease reputation factor (owner only).
+
+        Args:
+            request: Non-attestor decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_non_attestor_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} non-attestor decrease reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_validator_absent_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update validator absent decrease reputation factor (owner only).
+
+        Args:
+            request: Validator absent decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_validator_absent_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} validator absent decrease reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_validator_non_consensus_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update validator non-consensus decrease reputation factor (owner only).
+
+        Args:
+            request: Validator non-consensus decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_validator_non_consensus_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} validator non-consensus decrease reputation factor updated successfully"
+            ),
+        )
+
+    def owner_update_non_consensus_attestor_decrease_reputation_factor(
+        self, request: SubnetConfigUpdateRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Update non-consensus attestor decrease reputation factor (owner only).
+
+        Args:
+            request: Non-consensus attestor decrease reputation factor update request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        return self._execute_owner_value_update(
+            request,
+            keypair,
+            call_function="owner_update_non_consensus_attestor_decrease_reputation_factor",
+            success_message=(
+                "Subnet {subnet_id} non-consensus attestor decrease reputation factor updated successfully"
+            ),
+        )
+
+    # ============================================================================
+    # SUBNET OWNERSHIP TRANSFER
+    # ============================================================================
+
+    def transfer_subnet_ownership(
+        self, request: SubnetOwnershipTransferRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Transfer subnet ownership.
+
+        Args:
+            request: Subnet ownership transfer request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Transferring subnet {request.subnet_id} ownership to {request.new_owner}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="transfer_subnet_ownership",
+                call_params={
+                    "subnet_id": request.subnet_id,
+                    "new_owner": request.new_owner,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} ownership transfer initiated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error transferring subnet ownership: {e}")
+            return {"success": False, "error": str(e)}
+
+    def accept_subnet_ownership(
+        self, request: SubnetOwnershipAcceptRequest, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Accept subnet ownership.
+
+        Args:
+            request: Subnet ownership accept request
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Accepting subnet {request.subnet_id} ownership")
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="accept_subnet_ownership",
+                call_params={"subnet_id": request.subnet_id},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {request.subnet_id} ownership accepted successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error accepting subnet ownership: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # SUBNET EMERGENCY CONTROLS
+    # ============================================================================
+
+    def owner_set_emergency_validator_set(
+        self, subnet_id: int, subnet_node_ids: list[int], keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Override the validator set for a subnet (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            subnet_node_ids: List of subnet node IDs to be used as validators
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            sorted_ids = sorted(subnet_node_ids)
+            logger.info(
+                f"Setting emergency validator set for subnet {subnet_id}: {sorted_ids}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_set_emergency_validator_set",
+                call_params={"subnet_id": subnet_id, "subnet_node_ids": sorted_ids},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} emergency validator set updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(
+                f"Error setting emergency validator set for subnet {subnet_id}: {e}"
+            )
+            return {"success": False, "error": str(e)}
+
+    def owner_add_bootnode_access(
+        self, subnet_id: int, new_account: str, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Grant bootnode access to an account (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            new_account: Account ID to add
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            validate_address(new_account)
+            logger.info(
+                f"Adding bootnode access for subnet {subnet_id} to {new_account}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_add_bootnode_access",
+                call_params={"subnet_id": subnet_id, "new_account": new_account},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} bootnode access granted to {new_account}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error adding bootnode access for subnet {subnet_id}: {e}")
+            return {"success": False, "error": str(e)}
+
+    def owner_remove_bootnode_access(
+        self, subnet_id: int, remove_account: str, keypair: Keypair
+    ) -> dict[str, Any]:
+        """
+        Remove bootnode access from an account (owner only).
+
+        Args:
+            subnet_id: The subnet ID
+            remove_account: Account ID to remove
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            validate_address(remove_account)
+            logger.info(
+                f"Removing bootnode access for subnet {subnet_id} from {remove_account}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="owner_remove_bootnode_access",
+                call_params={"subnet_id": subnet_id, "remove_account": remove_account},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} bootnode access revoked from {remove_account}"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error removing bootnode access for subnet {subnet_id}: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # BOOTNODE MANAGEMENT
+    # ============================================================================
+
+    def update_bootnodes(
+        self,
+        subnet_id: int,
+        add_bootnodes: list[str],
+        remove_bootnodes: list[str],
+        keypair: Keypair,
+    ) -> dict[str, Any]:
+        """
+        Update subnet bootnodes.
+
+        Args:
+            subnet_id: The subnet ID
+            add_bootnodes: list of bootnode addresses to add
+            remove_bootnodes: list of bootnode addresses to remove
+            keypair: Keypair for signing the transaction
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(f"Updating subnet {subnet_id} bootnodes")
+
+            # Encode bootnode addresses to bytes
+            add_bootnodes_encoded = [addr.encode("utf-8") for addr in add_bootnodes]
+            remove_bootnodes_encoded = [
+                addr.encode("utf-8") for addr in remove_bootnodes
+            ]
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function="update_bootnodes",
+                call_params={
+                    "subnet_id": subnet_id,
+                    "add": add_bootnodes_encoded,
+                    "remove": remove_bootnodes_encoded,
+                },
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response["success"]:
+                response["message"] = (
+                    f"Subnet {subnet_id} bootnodes updated successfully"
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Error updating bootnodes: {e}")
+            return {"success": False, "error": str(e)}
+
+    # ============================================================================
+    # QUERY METHODS
+    # ============================================================================
+
+    def get_subnet_info(self, subnet_id: int) -> Optional[SubnetInfo]:
+        """Delegate to RPC layer for comprehensive subnet info."""
+        from ..rpc.subnet import SubnetRpcClient
+
+        try:
+            rpc_client = SubnetRpcClient(self.substrate)
+            return rpc_client.get_subnet_info(subnet_id)
+        except Exception as e:
+            logger.error(f"Error getting subnet info: {e}")
+            return None
+
+    def get_current_registration_cost(self) -> int:
+        """Get the current subnet registration cost."""
+        return self._get_current_registration_cost()
+
+    def list_subnets(self) -> list[SubnetInfo]:
+        """
+        list all registered subnets.
+
+        Returns:
+            list of SubnetInfo objects
+        """
+        try:
+            subnets = []
+
+            # Get total subnet count
+            total_subnets = (
+                self.substrate.query(
+                    module="Network", storage_function="TotalSubnetUids"
+                ).value
+                or 0
+            )
+
+            # Query each subnet
+            for subnet_id in range(1, total_subnets + 1):
+                subnet_info = self.get_subnet_info(subnet_id)
+                if subnet_info:
+                    subnets.append(subnet_info)
+
+            return subnets
+
+        except Exception as e:
+            logger.error(f"Error listing subnets: {e}")
+            return []
+
+    # ============================================================================
+    # PRIVATE HELPER METHODS
+    # ============================================================================
+
+    def _validate_registration_request(self, request: SubnetRegisterRequest):
+        """Validate the registration request."""
+        # Validate initial coldkeys
+        for coldkey in request.initial_coldkeys:
+            if not validate_address(coldkey):
+                raise ValueError(f"Invalid coldkey address format: {coldkey}")
+
+        # Validate bootnodes format
+        # Bootnodes is a set[str] in the model (matches BTreeSet in Rust)
+        # Ensure it's not None and filter out any None values
+        if request.bootnodes is None:
+            request.bootnodes = set()  # Default to empty set if None
+        else:
+            # Filter out None values from the set (shouldn't happen, but be safe)
+            request.bootnodes = {
+                bn for bn in request.bootnodes if bn is not None and isinstance(bn, str)
+            }
+
+        for bootnode in request.bootnodes:
+            if not isinstance(bootnode, str):
+                raise ValueError(f"Bootnode must be a string, got {type(bootnode)}")
+            if not bootnode.strip():
+                raise ValueError("Bootnode cannot be empty")
+
+    def _prepare_subnet_data(self, request: SubnetRegisterRequest) -> dict[str, Any]:
+        """
+        Prepare subnet data for the extrinsic call.
+
+        RegistrationSubnetData structure (from Rust):
+        - 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>  (validator_id -> max_registrations)
+        - bootnodes: BTreeMap<PeerId, BoundedVec<u8, ...>>
+        """
+
+        def encode_validator_limits(accounts: dict[int, int]) -> list[tuple[int, int]]:
+            encoded = []
+            for validator_id, max_registrations in accounts.items():
+                final_max_registrations = max(max_registrations, 1)
+                encoded.append((int(validator_id), final_max_registrations))
+
+            encoded.sort(key=lambda item: item[0])
+            return encoded
+
+        def encode_bootnodes(bootnodes: set[str]) -> list[tuple[bytes, bytes]]:
+            encoded = []
+            for bootnode in bootnodes:
+                if (
+                    bootnode is None
+                    or not isinstance(bootnode, str)
+                    or not bootnode.strip()
+                ):
+                    continue
+
+                parts = bootnode.rsplit("/p2p/", 1)
+                if len(parts) != 2 or not parts[1].strip():
+                    raise ValueError(
+                        f"Bootnode must include a peer id using /p2p/<peer_id>: {bootnode}"
+                    )
+
+                multiaddr = bootnode.strip()
+                peer_id = parts[1].strip()
+                if not multiaddr:
+                    raise ValueError(f"Bootnode multiaddr cannot be empty: {bootnode}")
+
+                encoded.append((encode_peer_id(peer_id), _encode_multiaddr(multiaddr)))
+
+            encoded.sort(key=lambda item: item[0])
+            return encoded
+
+        initial_validators_list = encode_validator_limits(request.initial_validators)
+        bootnodes_list = encode_bootnodes(request.bootnodes or set())
+
+        return {
+            "name": request.name.encode("utf-8") if request.name else b"",
+            "repo": request.repo.encode("utf-8") if request.repo else b"",
+            "description": (
+                request.description.encode("utf-8") if request.description else b""
+            ),
+            "misc": request.misc.encode("utf-8") if request.misc else b"",
+            "min_stake": request.min_stake,
+            "max_stake": request.max_stake,
+            "delegate_stake_percentage": request.delegate_stake_percentage,
+            "initial_validators": initial_validators_list,
+            "bootnodes": bootnodes_list,
+        }
+
+    def _get_current_registration_cost(self) -> int:
+        """
+        Get the current registration cost from the chain.
+
+        Uses ChainRpcClient to query storage and calculate current cost.
+        Falls back to a safe default if query fails.
+        """
+        try:
+            from ..rpc import ChainRpcClient
+
+            chain_rpc = ChainRpcClient(self.substrate)
+            cost = chain_rpc.get_subnet_registration_cost()
+
+            if cost is not None:
+                logger.info(f"Current registration cost: {cost / 1e18:.2f} TENSOR")
+                return cost
+
+            # Fallback: return high value to ensure it passes
+            logger.warning("Could not get registration cost, using default 100 TENSOR")
+            return int(100 * 1e18)
+        except Exception as e:
+            logger.warning(
+                f"Error getting registration cost: {e}, using default 100 TENSOR"
+            )
+            # Return safe default
+            return int(100 * 1e18)
+
+    def _get_current_epoch(self) -> int:
+        """Get the current epoch number."""
+        try:
+            block_header = self.substrate.get_block_header()
+            current_block = block_header.get("number", 0) if block_header else 0
+            epoch_length = (
+                self.substrate.query(
+                    module="Network", storage_function="EpochLength"
+                ).value
+                or 300
+            )
+
+            return current_block // epoch_length
+        except Exception as e:
+            logger.warning(f"Could not get current epoch: {e}")
+            return 0
+
+    def _execute_owner_value_update(
+        self,
+        request: SubnetConfigUpdateRequest,
+        keypair: Keypair,
+        call_function: str,
+        success_message: str,
+    ) -> dict[str, Any]:
+        """
+        Helper to execute owner-only configuration updates with a single value.
+
+        Args:
+            request: Configuration update request with subnet_id and value
+            keypair: Keypair for signing the transaction
+            call_function: Runtime call to execute
+            success_message: Message to attach upon success
+
+        Returns:
+            dictionary with operation result
+        """
+        try:
+            logger.info(
+                f"Calling {call_function} for subnet {request.subnet_id} with value {request.value}"
+            )
+
+            call = self.substrate.compose_call(
+                call_module="Network",
+                call_function=call_function,
+                call_params={"subnet_id": request.subnet_id, "value": request.value},
+            )
+
+            response = self._submit_extrinsic(call, keypair)
+
+            if response.get("success"):
+                response["message"] = success_message.format(
+                    subnet_id=request.subnet_id
+                )
+
+            return response
+
+        except Exception as e:
+            logger.error(
+                f"Error executing {call_function} for subnet {request.subnet_id}: {e}"
+            )
+            return {"success": False, "error": str(e)}
+
+    # _submit_extrinsic method is now inherited from BaseExtrinsicClient
+
+    def _extract_registration_event(self, response) -> dict[str, Any]:
+        """Extract subnet registration event data from the response."""
+        event_data = {}
+
+        try:
+            for event in response.triggered_events:
+                if (
+                    event.value["module_id"] == "Network"
+                    and event.value["event_id"] == "SubnetRegistered"
+                ):
+                    attributes = event.value.get("attributes", [])
+                    # SubnetRegistered event has 3 attributes: [owner, name, subnet_id]
+                    if isinstance(attributes, list) and len(attributes) >= 3:
+                        # Handle name which might be bytes
+                        name_value = attributes[1]
+                        if isinstance(name_value, bytes):
+                            name_str = name_value.decode("utf-8")
+                        elif (
+                            isinstance(name_value, (list, tuple))
+                            and len(name_value) > 0
+                        ):
+                            name_str = (
+                                name_value[0].decode("utf-8")
+                                if isinstance(name_value[0], bytes)
+                                else str(name_value[0])
+                            )
+                        else:
+                            name_str = str(name_value)
+
+                        event_data = {
+                            "subnet_id": attributes[2],  # subnet_id
+                            "owner": attributes[0],  # owner
+                            "name": name_str,  # name
+                        }
+                    break
+        except Exception as e:
+            logger.warning(f"Could not extract event data: {e}")
+
+        return event_data
+
+    def _extract_registration_event_from_result(
+        self, result: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Extract subnet registration event data from result dict."""
+        event_data = {}
+
+        try:
+            events = result.get("events", [])
+            logger.debug(f"Extracting from {len(events)} events")
+
+            for idx, event in enumerate(events):
+                logger.debug(f"Event {idx}: {type(event)}")
+
+                # Check if event has value attribute
+                if hasattr(event, "value"):
+                    event_value = event.value
+                    module_id = event_value.get("module_id", "")
+                    event_id = event_value.get("event_id", "")
+
+                    if module_id == "Network" and event_id == "SubnetRegistered":
+                        attributes = event_value.get("attributes", {})
+
+                        # Handle both dict and list formats
+                        if isinstance(attributes, dict):
+                            event_data = {
+                                "subnet_id": attributes.get("subnet_id"),
+                                "owner": attributes.get("owner"),
+                                "name": attributes.get("name"),
+                            }
+                        elif isinstance(attributes, list) and len(attributes) >= 3:
+                            # Handle name which might be bytes or a tuple
+                            name_value = attributes[1]
+                            if isinstance(name_value, bytes):
+                                name_str = name_value.decode("utf-8")
+                            elif (
+                                isinstance(name_value, (list, tuple))
+                                and len(name_value) > 0
+                            ):
+                                # If it's a tuple/list, take the first element
+                                name_str = (
+                                    name_value[0].decode("utf-8")
+                                    if isinstance(name_value[0], bytes)
+                                    else str(name_value[0])
+                                )
+                            else:
+                                name_str = str(name_value)
+
+                            event_data = {
+                                "subnet_id": attributes[2],
+                                "owner": attributes[0],
+                                "name": name_str,
+                            }
+
+                        break
+
+        except Exception as e:
+            logger.warning(f"Event extraction error: {e}")
+
+        return event_data
+
+    # _extract_error_message method is now inherited from BaseExtrinsicClient