meshtensor-cli 9.25.0__tar.gz → 9.26.0__tar.gz

{meshtensor_cli-9.25.0 → meshtensor_cli-9.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshtensor-cli
-Version: 9.25.0
+Version: 9.26.0
 Summary: Meshtensor CLI
 Author: meshtensor.com
 Requires-Python: >=3.9

{meshtensor_cli-9.25.0 → meshtensor_cli-9.26.0}/meshtensor_cli/cli.py

@@ -125,7 +125,7 @@ except ImportError:
 
 
 logger = logging.getLogger("meshcli")
-_epilog = "Made with [bold red]:heart:[/bold red] by The Openτensor Foundaτion"
+_epilog = "Made with [bold red]:heart:[/bold red] by Grobb"
 
 np.set_printoptions(precision=8, suppress=True, floatmode="fixed")
 
@@ -288,7 +288,7 @@ class Options:
         "--meshtensor.network",
         "--chain",
         "--meshtensor.chain_endpoint",
-        help="The meshtensor network to connect to. Default: swarm.",
+        help="The meshtensor network to connect to. Default: finney.",
         show_default=False,
     )
     netuids = typer.Option(
@@ -1432,18 +1432,6 @@ class CLIManager:
         self.governance_app.command("signal-golr")(self.governance_signal_golr)
         self.governance_app.command("update-scores")(self.governance_update_scores)
         self.governance_app.command("distribute-rewards")(self.governance_distribute_rewards)
-        self.governance_app.command("claim-rewards")(self.governance_claim_rewards)
-        self.governance_app.command("submit-preimage")(self.governance_submit_preimage)
-        self.governance_app.command("set-track-coefficients")(self.governance_set_track_coefficients)
-        self.governance_app.command("set-config")(self.governance_set_config)
-        self.governance_app.command("set-golr-config")(self.governance_set_golr_config)
-        self.governance_app.command("prune-accounts")(self.governance_prune_accounts)
-        self.governance_app.command("endorse")(self.governance_endorse)
-        self.governance_app.command("cancel")(self.governance_cancel)
-        self.governance_app.command("approve-treasury")(self.governance_approve_treasury)
-        self.governance_app.command("status")(self.governance_status)
-        self.governance_app.command("my-rewards")(self.governance_my_rewards)
-        self.governance_app.command("my-delegations")(self.governance_my_delegations)
 
         # Treasury commands
         self.treasury_app.command("propose")(self.treasury_propose)
@@ -1497,8 +1485,8 @@ class CLIManager:
         Intelligently initializes a connection to the chain, depending on the supplied (or in config) values. Sets the
         `self.meshtensor` object to this created connection.
 
-        :param network: Network name (e.g. swarm, test, etc.) or
-                        chain endpoint (e.g. ws://127.0.0.1:9945, wss://entrypoint-swarm.opentensor.ai:443)
+        :param network: Network name (e.g. finney, test, etc.) or
+                        chain endpoint (e.g. ws://127.0.0.1:9945, wss://entrypoint-finney.opentensor.ai:443)
         """
         with warnings.catch_warnings():
             warnings.filterwarnings(
@@ -1800,11 +1788,11 @@ class CLIManager:
             [green]$[/green] meshcli config set
 
         Set specific values:
-            [green]$[/green] meshcli config set --wallet-name default --network swarm
+            [green]$[/green] meshcli config set --wallet-name default --network finney
             [green]$[/green] meshcli config set --safe-staking --rate-tolerance 0.1
 
         [bold]NOTE[/bold]:
-        - Network values can be network names (e.g., 'swarm', 'test') or websocket URLs
+        - Network values can be network names (e.g., 'finney', 'test') or websocket URLs
         - Rate tolerance is specified as a decimal (e.g., 0.05 for 0.05%)
         - Changes are saved to ~/.meshtensor/meshcli.yaml
         - Use '[green]$[/green] meshcli config get' to view current settings
@@ -2031,7 +2019,7 @@ class CLIManager:
         for key, value in self.config.items():
             if key == "network":
                 if value is None:
-                    value = "None (default = swarm)"
+                    value = "None (default = finney)"
                 else:
                     if value in Constants.networks:
                         value = value + f" ({Constants.network_map[value]})"
@@ -3108,7 +3096,7 @@ class CLIManager:
 
         This command is useful for users who need test tokens for operations on a local blockchain.
 
-        [blue bold]IMPORTANT[/blue bold]: THIS COMMAND IS DISABLED ON SWARM AND TESTNET.
+        [blue bold]IMPORTANT[/blue bold]: THIS COMMAND IS DISABLED ON FINNEY AND TESTNET.
 
         USAGE
 
@@ -3119,7 +3107,7 @@ class CLIManager:
 
         [green]$[/green] meshcli wallet faucet --faucet.num_processes 4 --faucet.cuda.use_cuda
 
-        [bold]Note[/bold]: This command is meant for used in local environments where users can experiment with the blockchain without using real MESH tokens. Users must have the necessary hardware setup, especially when opting for CUDA-based GPU calculations. It is currently disabled on testnet and mainnet (swarm). You can only use this command on a local blockchain.
+        [bold]Note[/bold]: This command is meant for used in local environments where users can experiment with the blockchain without using real MESH tokens. Users must have the necessary hardware setup, especially when opting for CUDA-based GPU calculations. It is currently disabled on testnet and mainnet (finney). You can only use this command on a local blockchain.
         """
         # TODO should we add json_output?
         wallet = self.wallet_ask(
@@ -3909,12 +3897,12 @@ class CLIManager:
         [green]$[/green] meshcli wallet history
 
         """
-        # TODO: Fetch effective network and redirect users accordingly - this only works on swarm
+        # TODO: Fetch effective network and redirect users accordingly - this only works on finney
         # TODO: Add json_output if this gets re-enabled
-        # no_use_config_str = "Using the network [dark_orange]swarm[/dark_orange] and ignoring network/chain configs"
+        # no_use_config_str = "Using the network [dark_orange]finney[/dark_orange] and ignoring network/chain configs"
 
         # if self.config.get("network"):
-        #     if self.config.get("network") != "swarm":
+        #     if self.config.get("network") != "finney":
         #         console.print(no_use_config_str)
 
         # For Rao games
@@ -7537,7 +7525,7 @@ class CLIManager:
         )
 
         meshtensor = self.initialize_chain(network)
-        non_archives = ["swarm", "latent-lite"]
+        non_archives = ["finney", "latent-lite"]
         if not current_only and meshtensor.network in non_archives + [
             Constants.network_map[x] for x in non_archives
         ]:
@@ -8179,7 +8167,7 @@ class CLIManager:
 
         EXAMPLE
 
-        Show the metagraph of the root network (netuid 0) on swarm (mainnet):
+        Show the metagraph of the root network (netuid 0) on finney (mainnet):
 
             [green]$[/green] meshcli subnet metagraph --netuid 0
 
@@ -10145,7 +10133,7 @@ class CLIManager:
         ),
     ):
         """
-        This command will give you the latency of all swarm-like network in additional to any additional networks you specify via the '--network' flag
+        This command will give you the latency of all finney-like network in additional to any additional networks you specify via the '--network' flag
 
         The results are three-fold. One column is the overall time to initialise a connection, send the requests, and wait for the results. The second column measures single ping-pong speed once connected. The third makes a real world call to fetch the chain head.
 
@@ -10485,11 +10473,6 @@ class CLIManager:
     def governance_history(
         self,
         network: Optional[list[str]] = Options.network,
-        limit: int = typer.Option(
-            20,
-            "--limit",
-            help="Maximum number of referenda to show.",
-        ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
         json_output: bool = Options.json_output,
@@ -10499,7 +10482,6 @@ class CLIManager:
         return self._run_command(
             governance.governance_history(
                 subtensor=self.initialize_chain(network),
-                limit=limit,
                 quiet=quiet,
                 verbose=verbose,
                 output_json=json_output,
@@ -10581,354 +10563,6 @@ class CLIManager:
             )
         )
 
-    def governance_claim_rewards(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Claim pending governance rewards from the reward pool."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_claim_rewards(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_submit_preimage(
-        self,
-        call_data: str = typer.Argument(
-            ...,
-            help="Hex-encoded SCALE bytes of the runtime call (with or without 0x prefix).",
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Submit a preimage of a runtime call on-chain."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_submit_preimage(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                call_data=call_data,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_track_coefficients(
-        self,
-        track_id: int = typer.Option(
-            ..., "--track", help="Governance track ID (0-5)."
-        ),
-        alpha: int = typer.Option(
-            ..., "--alpha", help="Quadratic stake weight (0-1000)."
-        ),
-        beta: int = typer.Option(
-            ..., "--beta", help="Contribution weight (0-1000)."
-        ),
-        gamma: int = typer.Option(
-            ..., "--gamma", help="Reserved/future weight (0-1000)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update VP formula coefficients for a governance track (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_track_coefficients(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                track_id=track_id,
-                alpha=alpha,
-                beta=beta,
-                gamma=gamma,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_config(
-        self,
-        min_contribution_floor: int = typer.Option(
-            ..., "--min-contribution-floor", help="Minimum CW floor (0-1000, default 150)."
-        ),
-        max_delegation_pct: int = typer.Option(
-            ..., "--max-delegation-pct", help="Max delegated VP per delegatee (0-1000, default 50)."
-        ),
-        delegation_factor: int = typer.Option(
-            ..., "--delegation-factor", help="Delegation decay factor (0-1000, default 900)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update core governance configuration parameters (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_config(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                min_contribution_floor=min_contribution_floor,
-                max_delegation_pct=max_delegation_pct,
-                delegation_factor=delegation_factor,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_golr_config(
-        self,
-        paralysis_days: int = typer.Option(
-            ..., "--paralysis-days", help="Days of inactivity before GoLR (min 30)."
-        ),
-        threshold_pct: int = typer.Option(
-            ..., "--threshold-pct", help="Validator supermajority percentage (0-100)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update GoLR (Governance of Last Resort) parameters (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_golr_config(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                paralysis_days=paralysis_days,
-                threshold_pct=threshold_pct,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_prune_accounts(
-        self,
-        accounts: list[str] = typer.Option(
-            ..., "--accounts", help="SS58 addresses to prune (max 500)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Prune governance storage for zero-balance accounts (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_prune_accounts(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                accounts=accounts,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_endorse(
-        self,
-        ref_index: int = typer.Option(
-            ..., "--ref-index", help="Referendum index to endorse."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Endorse a referendum as a Technical Committee member."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_endorse(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                ref_index=ref_index,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_cancel(
-        self,
-        ref_index: int = typer.Option(
-            ..., "--ref-index", help="Referendum index to cancel."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Cancel an active referendum (requires root origin)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_cancel(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                ref_index=ref_index,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_approve_treasury(
-        self,
-        proposal_id: int = typer.Option(
-            ..., "--proposal-id", help="Treasury proposal ID to approve."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Approve a treasury proposal (requires root origin)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_approve_treasury(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                proposal_id=proposal_id,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_status(
-        self,
-        network: Optional[list[str]] = Options.network,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display governance system status overview."""
-        self.verbosity_handler(quiet, verbose)
-        return self._run_command(
-            governance.governance_status(
-                subtensor=self.initialize_chain(network),
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_my_rewards(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display governance rewards and contribution score for your wallet."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_my_rewards(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_my_delegations(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display active governance delegations for your wallet."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_my_delegations(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
     # =========================================================================
     # Treasury commands
     # =========================================================================

{meshtensor_cli-9.25.0 → meshtensor_cli-9.26.0}/meshtensor_cli/src/__init__.py

@@ -6,24 +6,24 @@ from typing import Any, Optional
 class Constants:
     networks = [
         "local",
-        "swarm",
+        "finney",
         "test",
         "archive",
         "meshlet",
         "dev",
         "latent-lite",
     ]
-    swarm_entrypoint = "wss://entrypoint-swarm.opentensor.ai:443"
-    swarm_test_entrypoint = "wss://test.swarm.opentensor.ai:443"
+    finney_entrypoint = "wss://entrypoint-finney.opentensor.ai:443"
+    finney_test_entrypoint = "wss://test.finney.opentensor.ai:443"
     archive_entrypoint = "wss://archive.chain.opentensor.ai:443"
     local_entrypoint = "ws://127.0.0.1:9944"
     meshlet_entrypoint = "wss://meshlet.chain.opentensor.ai:443"
     dev_entrypoint = "wss://dev.chain.opentensor.ai:443"
     latent_lite_entrypoint = "wss://lite.sub.latent.to:443"
-    lite_nodes = [swarm_entrypoint, latent_lite_entrypoint]
+    lite_nodes = [finney_entrypoint, latent_lite_entrypoint]
     network_map = {
-        "swarm": swarm_entrypoint,
-        "test": swarm_test_entrypoint,
+        "finney": finney_entrypoint,
+        "test": finney_test_entrypoint,
         "archive": archive_entrypoint,
         "local": local_entrypoint,
         "dev": dev_entrypoint,
@@ -31,7 +31,7 @@ class Constants:
         "latent-lite": latent_lite_entrypoint,
     }
     genesis_block_hash_map = {
-        "swarm": "0x2f0555cc76fc2840a25a6ea3b9637146806f1f44b090c175ffde2a7e5ab36c03",
+        "finney": "0x2f0555cc76fc2840a25a6ea3b9637146806f1f44b090c175ffde2a7e5ab36c03",
         "test": "0x8f9cf856bf558a14440e75569c9e58594757048d7b3a84b5d25f6bd978263105",
     }
     delegates_detail_url = "https://raw.githubusercontent.com/opentensor/meshtensor-delegates/main/public/delegates.json"
@@ -120,7 +120,7 @@ class Defaults:
         dictionary = {}
 
     class meshtensor:
-        network = "swarm"
+        network = "finney"
         chain_endpoint = None
         _mock = False
 
@@ -615,14 +615,14 @@ UNITS = [
 
 NETWORK_EXPLORER_MAP = {
     "opentensor": {
-        "local": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-swarm.opentensor.ai%3A443#/explorer",
-        "endpoint": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-swarm.opentensor.ai%3A443#/explorer",
-        "swarm": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-swarm.opentensor.ai%3A443#/explorer",
+        "local": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-finney.opentensor.ai%3A443#/explorer",
+        "endpoint": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-finney.opentensor.ai%3A443#/explorer",
+        "finney": "https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-finney.opentensor.ai%3A443#/explorer",
     },
     "taostats": {
         "local": "https://x.taostats.io",
         "endpoint": "https://x.taostats.io",
-        "swarm": "https://x.taostats.io",
+        "finney": "https://x.taostats.io",
     },
 }
 
@@ -635,54 +635,54 @@ class RootSudoOnly(Enum):
 
 HYPERPARAMS = {
     # meshcli name: (meshtensor method, root-only enum)
-    "rho": ("sudo_set_rho", RootSudoOnly.FALSE),
-    "kappa": ("sudo_set_kappa", RootSudoOnly.TRUE),
-    "immunity_period": ("sudo_set_immunity_period", RootSudoOnly.FALSE),
-    "min_allowed_weights": ("sudo_set_min_allowed_weights", RootSudoOnly.FALSE),
-    "max_weights_limit": ("sudo_set_max_weight_limit", RootSudoOnly.FALSE),
-    "tempo": ("sudo_set_tempo", RootSudoOnly.TRUE),
-    "min_difficulty": ("sudo_set_min_difficulty", RootSudoOnly.TRUE),
-    "max_difficulty": ("sudo_set_max_difficulty", RootSudoOnly.FALSE),
-    "weights_version": ("sudo_set_weights_version_key", RootSudoOnly.FALSE),
-    "weights_rate_limit": ("sudo_set_weights_set_rate_limit", RootSudoOnly.TRUE),
-    "adjustment_interval": ("sudo_set_adjustment_interval", RootSudoOnly.TRUE),
-    "activity_cutoff": ("sudo_set_activity_cutoff", RootSudoOnly.FALSE),
+    "rho": ("set_rho", RootSudoOnly.FALSE),
+    "kappa": ("set_kappa", RootSudoOnly.TRUE),
+    "immunity_period": ("set_immunity_period", RootSudoOnly.FALSE),
+    "min_allowed_weights": ("set_min_allowed_weights", RootSudoOnly.FALSE),
+    "max_weights_limit": ("set_max_weight_limit", RootSudoOnly.FALSE),
+    "tempo": ("set_tempo", RootSudoOnly.TRUE),
+    "min_difficulty": ("set_min_difficulty", RootSudoOnly.TRUE),
+    "max_difficulty": ("set_max_difficulty", RootSudoOnly.FALSE),
+    "weights_version": ("set_weights_version_key", RootSudoOnly.FALSE),
+    "weights_rate_limit": ("set_weights_set_rate_limit", RootSudoOnly.TRUE),
+    "adjustment_interval": ("set_adjustment_interval", RootSudoOnly.TRUE),
+    "activity_cutoff": ("set_activity_cutoff", RootSudoOnly.FALSE),
     "target_regs_per_interval": (
-        "sudo_set_target_registrations_per_interval",
+        "set_target_registrations_per_interval",
         RootSudoOnly.TRUE,
     ),
-    "min_burn": ("sudo_set_min_burn", RootSudoOnly.FALSE),
-    "max_burn": ("sudo_set_max_burn", RootSudoOnly.TRUE),
-    "bonds_moving_avg": ("sudo_set_bonds_moving_average", RootSudoOnly.FALSE),
-    "max_regs_per_block": ("sudo_set_max_registrations_per_block", RootSudoOnly.TRUE),
-    "serving_rate_limit": ("sudo_set_serving_rate_limit", RootSudoOnly.FALSE),
-    "max_validators": ("sudo_set_max_allowed_validators", RootSudoOnly.TRUE),
-    "adjustment_alpha": ("sudo_set_adjustment_alpha", RootSudoOnly.FALSE),
-    "difficulty": ("sudo_set_difficulty", RootSudoOnly.TRUE),
+    "min_burn": ("set_min_burn", RootSudoOnly.FALSE),
+    "max_burn": ("set_max_burn", RootSudoOnly.TRUE),
+    "bonds_moving_avg": ("set_bonds_moving_average", RootSudoOnly.FALSE),
+    "max_regs_per_block": ("set_max_registrations_per_block", RootSudoOnly.TRUE),
+    "serving_rate_limit": ("set_serving_rate_limit", RootSudoOnly.FALSE),
+    "max_validators": ("set_max_allowed_validators", RootSudoOnly.TRUE),
+    "adjustment_alpha": ("set_adjustment_alpha", RootSudoOnly.FALSE),
+    "difficulty": ("set_difficulty", RootSudoOnly.TRUE),
     "commit_reveal_period": (
-        "sudo_set_commit_reveal_weights_interval",
+        "set_commit_reveal_weights_interval",
         RootSudoOnly.FALSE,
     ),
     "commit_reveal_weights_enabled": (
-        "sudo_set_commit_reveal_weights_enabled",
+        "set_commit_reveal_weights_enabled",
         RootSudoOnly.FALSE,
     ),
-    "alpha_values": ("sudo_set_alpha_values", RootSudoOnly.FALSE),
-    "liquid_alpha_enabled": ("sudo_set_liquid_alpha_enabled", RootSudoOnly.FALSE),
+    "alpha_values": ("set_alpha_values", RootSudoOnly.FALSE),
+    "liquid_alpha_enabled": ("set_liquid_alpha_enabled", RootSudoOnly.FALSE),
     "registration_allowed": (
-        "sudo_set_network_registration_allowed",
+        "set_network_registration_allowed",
         RootSudoOnly.TRUE,
     ),
     "network_pow_registration_allowed": (
-        "sudo_set_network_pow_registration_allowed",
+        "set_network_pow_registration_allowed",
         RootSudoOnly.FALSE,
     ),
-    "yuma3_enabled": ("sudo_set_yuma3_enabled", RootSudoOnly.FALSE),
-    "alpha_sigmoid_steepness": ("sudo_set_alpha_sigmoid_steepness", RootSudoOnly.TRUE),
+    "yuma3_enabled": ("set_yuma3_enabled", RootSudoOnly.FALSE),
+    "alpha_sigmoid_steepness": ("set_alpha_sigmoid_steepness", RootSudoOnly.TRUE),
     "user_liquidity_enabled": ("toggle_user_liquidity", RootSudoOnly.COMPLICATED),
-    "bonds_reset_enabled": ("sudo_set_bonds_reset_enabled", RootSudoOnly.FALSE),
-    "transfers_enabled": ("sudo_set_toggle_transfer", RootSudoOnly.FALSE),
-    "min_allowed_uids": ("sudo_set_min_allowed_uids", RootSudoOnly.TRUE),
+    "bonds_reset_enabled": ("set_bonds_reset_enabled", RootSudoOnly.FALSE),
+    "transfers_enabled": ("set_toggle_transfer", RootSudoOnly.FALSE),
+    "min_allowed_uids": ("set_min_allowed_uids", RootSudoOnly.TRUE),
     # Note: These are displayed but not directly settable via HYPERPARAMS
     # They are derived or set via other mechanisms
     "alpha_high": ("", RootSudoOnly.FALSE),  # Derived from alpha_values