Feature/gus/liquid alpha params

bittensor/chain_data.py

@@ -186,6 +186,9 @@
                 ["difficulty", "Compact<u64>"],
                 ["commit_reveal_weights_interval", "Compact<u64>"],
                 ["commit_reveal_weights_enabled", "bool"],
+                ["alpha_high", "Compact<u16>"],
+                ["alpha_low", "Compact<u16>"],
+                ["liquid_alpha_enabled", "bool"],
             ],
         },
     }
@@ -981,6 +984,9 @@ class SubnetHyperparameters:
     difficulty: int
     commit_reveal_weights_interval: int
     commit_reveal_weights_enabled: bool
+    alpha_high: int
+    alpha_low: int
+    liquid_alpha_enabled: bool
 
     @classmethod
     def from_vec_u8(cls, vec_u8: List[int]) -> Optional["SubnetHyperparameters"]:
@@ -1033,6 +1039,9 @@ def fix_decoded_values(cls, decoded: Dict) -> "SubnetHyperparameters":
             difficulty=decoded["difficulty"],
             commit_reveal_weights_interval=decoded["commit_reveal_weights_interval"],
             commit_reveal_weights_enabled=decoded["commit_reveal_weights_enabled"],
+            alpha_high=decoded["alpha_high"],
+            alpha_low=decoded["alpha_low"],
+            liquid_alpha_enabled=decoded["liquid_alpha_enabled"],
         )
 
     def to_parameter_dict(

bittensor/commands/network.py

@@ -17,10 +17,10 @@
 
 import argparse
 import bittensor
-from . import defaults
+from . import defaults  # type: ignore
 from rich.prompt import Prompt
 from rich.table import Table
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Union, Tuple
 from .utils import (
     get_delegates_details,
     DelegatesDetails,
@@ -330,6 +330,8 @@ def add_args(parser: argparse.ArgumentParser):
     "bonds_moving_avg": "sudo_set_bonds_moving_average",
     "commit_reveal_weights_interval": "sudo_set_commit_reveal_weights_interval",
     "commit_reveal_weights_enabled": "sudo_set_commit_reveal_weights_enabled",
+    "alpha_values": "sudo_set_alpha_values",
+    "liquid_alpha_enabled": "sudo_set_liquid_alpha_enabled",
 }
 
 
@@ -388,18 +390,25 @@ def _run(
             cli.config.param == "network_registration_allowed"
             or cli.config.param == "network_pow_registration_allowed"
             or cli.config.param == "commit_reveal_weights_enabled"
+            or cli.config.param == "liquid_alpha_enabled"
         ):
             cli.config.value = (
                 True
                 if (cli.config.value.lower() == "true" or cli.config.value == "1")
                 else False
             )
 
+        is_allowed_value, value = allowed_value(cli.config.param, cli.config.value)
+        if not is_allowed_value:
+            raise ValueError(
+                f"Hyperparameter {cli.config.param} value is not within bounds. Value is {cli.config.value} but must be {value}"
+            )
+
         subtensor.set_hyperparameter(
             wallet,
             netuid=cli.config.netuid,
             parameter=cli.config.param,
-            value=cli.config.value,
+            value=value,
             prompt=not cli.config.no_prompt,
         )
 
@@ -638,3 +647,40 @@ def add_args(parser: argparse.ArgumentParser):
             default=False,
         )
         bittensor.subtensor.add_args(parser)
+
+
+def allowed_value(
+    param: str, value: Union[str, bool, float]
+) -> Tuple[bool, Union[str, list[float], float]]:
+    """
+    Check the allowed values on hyperparameters. Return False if value is out of bounds.
+    """
+    # Reminder error message ends like:  Value is {value} but must be {error_message}. (the second part of return statement)
+    # Check if value is a boolean, only allow boolean and floats
+    try:
+        if not isinstance(value, bool):
+            if param == "alpha_values":
+                # Split the string into individual values
+                alpha_low_str, alpha_high_str = value.split(",")
+                alpha_high = float(alpha_high_str)
+                alpha_low = float(alpha_low_str)
+
+                # Check alpha_high value
+                if alpha_high <= 52428 or alpha_high >= 65535:
+                    return (
+                        False,
+                        f"between 52428 and 65535 for alpha_high (but is {alpha_high})",
+                    )
+
+                # Check alpha_low value
+                if alpha_low < 0 or alpha_low > 52428:
+                    return (
+                        False,
+                        f"between 0 and 52428 for alpha_low (but is {alpha_low})",
+                    )
+
+                return True, [alpha_low, alpha_high]
+    except ValueError:
+        return False, "a number or a boolean"
+
+    return True, value

bittensor/commands/utils.py

@@ -186,10 +186,10 @@ def filter_netuids_by_registered_hotkeys(
         )
         netuids_with_registered_hotkeys.extend(netuids_list)
 
-    if cli.config.netuids == None or cli.config.netuids == []:
+    if not cli.config.netuids:
         netuids = netuids_with_registered_hotkeys
 
-    elif cli.config.netuids != []:
+    else:
         netuids = [netuid for netuid in netuids if netuid in cli.config.netuids]
         netuids.extend(netuids_with_registered_hotkeys)
 
@@ -216,6 +216,8 @@ def normalize_hyperparameters(
         "bonds_moving_avg": U64_NORMALIZED_FLOAT,
         "max_weight_limit": U16_NORMALIZED_FLOAT,
         "kappa": U16_NORMALIZED_FLOAT,
+        "alpha_high": U16_NORMALIZED_FLOAT,
+        "alpha_low": U16_NORMALIZED_FLOAT,
         "min_burn": Balance.from_rao,
         "max_burn": Balance.from_rao,
     }

bittensor/extrinsics/network.py

@@ -183,16 +183,38 @@ def set_hyperparameter_extrinsic(
             extrinsic_params = substrate.get_metadata_call_function(
                 "AdminUtils", extrinsic
             )
-            value_argument = extrinsic_params["fields"][
-                len(extrinsic_params["fields"]) - 1
-            ]
+            call_params = {"netuid": netuid}
+
+            # if input value is a list, iterate through the list and assign values
+            if isinstance(value, list):
+                # Create an iterator for the list of values
+                value_iterator = iter(value)
+                # Iterate over all value arguments and add them to the call_params dictionary
+                for value_argument in extrinsic_params["fields"]:
+                    if "netuid" not in str(value_argument["name"]):
+                        # Assign the next value from the iterator
+                        try:
+                            call_params[str(value_argument["name"])] = next(
+                                value_iterator
+                            )
+                        except StopIteration:
+                            raise ValueError(
+                                "Not enough values provided in the list for all parameters"
+                            )
+
+            else:
+                value_argument = extrinsic_params["fields"][
+                    len(extrinsic_params["fields"]) - 1
+                ]
+                call_params[str(value_argument["name"])] = value
 
             # create extrinsic call
             call = substrate.compose_call(
                 call_module="AdminUtils",
                 call_function=extrinsic,
-                call_params={"netuid": netuid, str(value_argument["name"]): value},
+                call_params=call_params,
             )
+
             extrinsic = substrate.create_signed_extrinsic(
                 call=call, keypair=wallet.coldkey
             )