bittensor-cli 9.23.0rc1__tar.gz → 9.23.0rc2__tar.gz

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.23.0rc1
+Version: 9.23.0rc2
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/cli.py

@@ -1198,6 +1198,9 @@ class CLIManager:
         self.sudo_app.command("trim", rich_help_panel=HELP_PANELS["SUDO"]["CONFIG"])(
             self.sudo_trim
         )
+        self.sudo_app.command(
+            "trigger-epoch", rich_help_panel=HELP_PANELS["SUDO"]["CONFIG"]
+        )(self.sudo_trigger_epoch)
         self.sudo_app.command(
             "stake-burn", rich_help_panel=HELP_PANELS["SUDO"]["CONFIG"]
         )(self.sudo_stake_burn)
@@ -7329,7 +7332,6 @@ class CLIManager:
             console.print("Available hyperparameters:\n")
 
             # Create a table to show hyperparameters with descriptions
-
             param_table = Table(
                 Column("[white]#", style="dim", width=4),
                 Column("[white]HYPERPARAMETER", style=COLORS.SU.HYPERPARAMETER),
@@ -7377,19 +7379,13 @@ class CLIManager:
                 description = metadata.get("description", "No description available.")
                 docs_link = metadata.get("docs_link", "")
                 if docs_link:
-                    # Show description text followed by clickable blue [link] at the end
                     console.print(
                         f"{description} [bright_blue underline link=https://{docs_link}]link[/]"
                     )
                 else:
                     console.print(f"{description}")
-                side_effects = metadata.get("side_effects", "")
-                if side_effects:
+                if side_effects := metadata.get("side_effects", ""):
                     console.print(f"[dim]Side Effects:[/dim] {side_effects}")
-                if docs_link:
-                    console.print(
-                        f"[dim]📚 Docs:[/dim] [link]https://{docs_link}[/link]\n"
-                    )
 
         if param_name in ["alpha_high", "alpha_low"]:
             if not prompt:
@@ -7398,16 +7394,13 @@ class CLIManager:
                     "They must be set together via the alpha_values parameter."
                 )
                 if json_output:
-                    json_str = json.dumps(
-                        {
+                    json_console.print_json(
+                        data={
                             "success": False,
                             "err_msg": err_msg,
                             "extrinsic_identifier": None,
-                        },
-                        ensure_ascii=True,
+                        }
                     )
-                    sys.stdout.write(json_str + "\n")
-                    sys.stdout.flush()
                 else:
                     print_error(
                         f"[{COLORS.SU.HYPERPARAM}]alpha_high[/{COLORS.SU.HYPERPARAM}] and "
@@ -7419,23 +7412,20 @@ class CLIManager:
             low_val = FloatPrompt.ask(f"Enter the new value for {arg__('alpha_low')}")
             high_val = FloatPrompt.ask(f"Enter the new value for {arg__('alpha_high')}")
             param_value = f"{low_val},{high_val}"
-        if param_name == "yuma_version":
+        elif param_name == "yuma_version":
             if not prompt:
                 err_msg = (
                     "yuma_version is set using a different hyperparameter (yuma3_enabled), "
                     "and thus cannot be set with `--no-prompt`"
                 )
                 if json_output:
-                    json_str = json.dumps(
-                        {
+                    json_console.print_json(
+                        data={
                             "success": False,
                             "err_msg": err_msg,
                             "extrinsic_identifier": None,
-                        },
-                        ensure_ascii=True,
+                        }
                     )
-                    sys.stdout.write(json_str + "\n")
-                    sys.stdout.flush()
                 else:
                     print_error(
                         f"[{COLORS.SU.HYPERPARAM}]yuma_version[/{COLORS.SU.HYPERPARAM}]"
@@ -7456,22 +7446,45 @@ class CLIManager:
                 param_value = "true" if question == "enable" else "false"
             else:
                 return False
+        elif param_name == "activity_cutoff":
+            err_msg = (
+                "activity_cutoff is now derived from activity_cutoff_factor "
+                "(cutoff blocks = factor × tempo ÷ 1000) and can no longer be set "
+                "directly. Set activity_cutoff_factor instead (per-mille units; "
+                "1000 = one full tempo)."
+            )
+            if json_output:
+                json_console.print_json(
+                    data={
+                        "success": False,
+                        "err_msg": err_msg,
+                        "extrinsic_identifier": None,
+                    }
+                )
+            else:
+                print_error(
+                    f"[{COLORS.SU.HYPERPARAM}]activity_cutoff[/{COLORS.SU.HYPERPARAM}] "
+                    f"is now derived from "
+                    f"[{COLORS.SU.HYPERPARAM}]activity_cutoff_factor[/{COLORS.SU.HYPERPARAM}] "
+                    f"(cutoff blocks = factor × tempo ÷ 1000). Set "
+                    f"[{COLORS.SU.HYPERPARAM}]activity_cutoff_factor[/{COLORS.SU.HYPERPARAM}] "
+                    f"instead (per-mille units; 1000 = one full tempo)."
+                )
+            return False
+
         if param_name == "subnet_is_active":
             err_msg = (
                 "subnet_is_active is set by using the 'btcli subnets start' command, "
                 "not via sudo set"
             )
             if json_output:
-                json_str = json.dumps(
-                    {
+                json_console.print_json(
+                    data={
                         "success": False,
                         "err_msg": err_msg,
                         "extrinsic_identifier": None,
-                    },
-                    ensure_ascii=True,
+                    }
                 )
-                sys.stdout.write(json_str + "\n")
-                sys.stdout.flush()
             else:
                 print_error(
                     f"[{COLORS.SU.HYPERPARAM}]subnet_is_active[/{COLORS.SU.HYPERPARAM}] "
@@ -7506,60 +7519,29 @@ class CLIManager:
             f"param_name: {param_name}\n"
             f"param_value: {param_value}"
         )
+
+        result, err_msg, ext_id = self._run_command(
+            sudo.sudo_set_hyperparameter(
+                wallet=wallet,
+                subtensor=self.initialize_chain(network),
+                netuid=netuid,
+                proxy=proxy,
+                param_name=param_name,
+                param_value=param_value,
+                normalize=normalize_value,
+                prompt=prompt,
+                json_output=json_output,
+            )
+        )
         if json_output:
-            try:
-                result, err_msg, ext_id = self._run_command(
-                    sudo.sudo_set_hyperparameter(
-                        wallet=wallet,
-                        subtensor=self.initialize_chain(network),
-                        netuid=netuid,
-                        proxy=proxy,
-                        param_name=param_name,
-                        param_value=param_value,
-                        normalize=normalize_value,
-                        prompt=prompt,
-                        json_output=json_output,
-                    )
-                )
-                json_str = json.dumps(
-                    {
-                        "success": result,
-                        "err_msg": err_msg,
-                        "extrinsic_identifier": ext_id,
-                    },
-                    ensure_ascii=True,
-                )
-                sys.stdout.write(json_str + "\n")
-                sys.stdout.flush()
-                return result
-            except Exception as e:
-                # Ensure JSON output even on exceptions
-                json_str = json.dumps(
-                    {
-                        "success": False,
-                        "err_msg": str(e),
-                        "extrinsic_identifier": None,
-                    },
-                    ensure_ascii=True,
-                )
-                sys.stdout.write(json_str + "\n")
-                sys.stdout.flush()
-                raise
-        else:
-            result, err_msg, ext_id = self._run_command(
-                sudo.sudo_set_hyperparameter(
-                    wallet=wallet,
-                    subtensor=self.initialize_chain(network),
-                    netuid=netuid,
-                    proxy=proxy,
-                    param_name=param_name,
-                    param_value=param_value,
-                    normalize=normalize_value,
-                    prompt=prompt,
-                    json_output=json_output,
-                )
+            json_console.print_json(
+                data={
+                    "success": result,
+                    "err_msg": err_msg,
+                    "extrinsic_identifier": ext_id,
+                }
             )
-            return result
+        return result
 
     def sudo_get(
         self,
@@ -7838,6 +7820,57 @@ class CLIManager:
             )
         )
 
+    def sudo_trigger_epoch(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: Optional[str] = Options.wallet_name,
+        wallet_path: Optional[str] = Options.wallet_path,
+        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
+        netuid: int = Options.netuid,
+        proxy: Optional[str] = Options.proxy,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+        json_output: bool = Options.json_output,
+        prompt: bool = Options.prompt,
+        decline: bool = Options.decline,
+        period: int = Options.period,
+    ):
+        """
+        Manually triggers an epoch for a subnet you own.
+
+        The epoch fires after the chain's admin freeze window has elapsed, during which
+        admin operations on the subnet are locked. This is rate-limited on-chain and
+        fails if a trigger is already pending, the next automatic epoch is imminent, or
+        commit-reveal is enabled on the subnet (disable it first via
+        'btcli sudo set --param commit_reveal_weights_enabled --value false').
+
+        EXAMPLE
+        [green]$[/green] btcli sudo trigger-epoch --netuid 95 --wallet-name my_wallet --wallet-hotkey my_hotkey
+        """
+        self.verbosity_handler(quiet, verbose, json_output, prompt)
+        proxy = self.is_valid_proxy_name_or_ss58(proxy, False)
+
+        wallet = self.wallet_ask(
+            wallet_name,
+            wallet_path,
+            wallet_hotkey,
+            ask_for=[WO.NAME, WO.PATH],
+            validate=WV.WALLET,
+        )
+        self._run_command(
+            sudo.trigger_epoch(
+                subtensor=self.initialize_chain(network),
+                wallet=wallet,
+                netuid=netuid,
+                period=period,
+                proxy=proxy,
+                json_output=json_output,
+                prompt=prompt,
+                decline=decline,
+                quiet=quiet,
+            )
+        )
+
     def sudo_stake_burn(
         self,
         network: Optional[list[str]] = Options.network,

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/__init__.py

@@ -584,10 +584,10 @@ HYPERPARAMS = {
     "kappa": ("sudo_set_kappa", RootSudoOnly.TRUE),
     "immunity_period": ("sudo_set_immunity_period", RootSudoOnly.FALSE),
     "min_allowed_weights": ("sudo_set_min_allowed_weights", RootSudoOnly.FALSE),
-    "tempo": ("sudo_set_tempo", RootSudoOnly.TRUE),
+    "tempo": ("set_tempo", RootSudoOnly.COMPLICATED),
     "weights_version": ("sudo_set_weights_version_key", RootSudoOnly.FALSE),
     "weights_rate_limit": ("sudo_set_weights_set_rate_limit", RootSudoOnly.TRUE),
-    "activity_cutoff": ("sudo_set_activity_cutoff", RootSudoOnly.FALSE),
+    "activity_cutoff_factor": ("set_activity_cutoff_factor", RootSudoOnly.COMPLICATED),
     "target_regs_per_interval": (
         "sudo_set_target_registrations_per_interval",
         RootSudoOnly.TRUE,
@@ -635,6 +635,10 @@ HYPERPARAMS = {
     "alpha_low": ("", RootSudoOnly.FALSE),  # Derived from alpha_values
     #
     "subnet_is_active": ("", RootSudoOnly.FALSE),  # Set via btcli subnets start
+    "activity_cutoff": (
+        "",
+        RootSudoOnly.FALSE,
+    ),  # Derived: activity_cutoff_factor × tempo / 1000
     "yuma_version": ("", RootSudoOnly.FALSE),  # Related to yuma3_enabled
     "max_allowed_uids": ("sudo_set_max_allowed_uids", RootSudoOnly.FALSE),
     "burn_increase_mult": ("sudo_set_burn_increase_mult", RootSudoOnly.FALSE),
@@ -645,9 +649,20 @@ HYPERPARAMS = {
     ),
 }
 
-# Maps a hyperparameter to a non-default pallet for sudo set calls. Empty by default
-# (all current hyperparameters live in the default pallet).
-HYPERPARAMS_MODULE: dict[str, str] = {}
+# Maps a hyperparameter to a non-default pallet for sudo set calls. Hyperparameters
+# not listed here live in the default pallet (AdminUtils).
+HYPERPARAMS_MODULE: dict[str, str] = {
+    "tempo": "SubtensorModule",
+    "activity_cutoff_factor": "SubtensorModule",
+}
+
+# Hyperparameters whose root-sudo path uses a different extrinsic than the owner path.
+# Maps btcli name -> (pallet, extrinsic) for the call wrapped in Sudo. Owner-side
+# set_tempo is bounded to [360, 50400] and rate-limited; root's sudo_set_tempo accepts
+# any u16 value.
+HYPERPARAMS_ROOT_EXTRINSIC: dict[str, tuple[str, str]] = {
+    "tempo": ("AdminUtils", "sudo_set_tempo"),
+}
 
 # Hyperparameter metadata: descriptions, side-effects, ownership, and documentation links
 HYPERPARAMS_METADATA = {
@@ -670,9 +685,9 @@ HYPERPARAMS_METADATA = {
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#minallowedweights",
     },
     "tempo": {
-        "description": "Number of blocks between epoch transitions",
-        "side_effects": "Lower tempo means more frequent updates but higher chain load. Higher tempo reduces frequency but may slow responsiveness.",
-        "owner_settable": False,
+        "description": "Number of blocks between automatic epoch transitions. Owner-settable between 360 and 50400 blocks (rate-limited to one change per 360 blocks); root can set any value via sudo.",
+        "side_effects": "Lower tempo means more frequent updates but higher chain load. Higher tempo reduces frequency but may slow responsiveness. Changing tempo resets the epoch cycle, so the next epoch fires a full tempo after the change.",
+        "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#tempo",
     },
     "weights_version": {
@@ -688,8 +703,14 @@ HYPERPARAMS_METADATA = {
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#weightsratelimit--commitmentratelimit",
     },
     "activity_cutoff": {
-        "description": "Minimum activity level required for neurons to remain active.",
-        "side_effects": "Lower values keep more neurons active; higher values prune inactive neurons more aggressively.",
+        "description": "Effective validator inactivity cutoff in blocks, computed as activity_cutoff_factor × tempo ÷ 1000. Read-only; set activity_cutoff_factor instead.",
+        "side_effects": "Lower values prune inactive validators more aggressively; higher values keep more validators active.",
+        "owner_settable": False,
+        "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#activitycutoff",
+    },
+    "activity_cutoff_factor": {
+        "description": "Tolerated validator inactivity as per-mille of tempo (1000 = one full tempo). Effective cutoff in blocks = factor × tempo ÷ 1000. Allowed range: 1000 to 50000.",
+        "side_effects": "Lower factors prune inactive validators more aggressively; higher factors tolerate longer inactivity. The effective cutoff scales with tempo.",
         "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#activitycutoff",
     },

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/bittensor/subtensor_interface.py

@@ -113,12 +113,14 @@ class SubtensorInterface:
             if (use_disk_cache or os.getenv("DISK_CACHE", "1") == "1")
             else AsyncSubstrateInterface
         )
-        self.substrate = substrate_class(
-            url=self.chain_endpoint,
-            ss58_format=SS58_FORMAT,
-            type_registry=TYPE_REGISTRY,
-            chain_name="Bittensor",
-            ws_shutdown_timer=None,
+        self.substrate: AsyncSubstrateInterface | DiskCachedAsyncSubstrateInterface = (
+            substrate_class(
+                url=self.chain_endpoint,
+                ss58_format=SS58_FORMAT,
+                type_registry=TYPE_REGISTRY,
+                chain_name="Bittensor",
+                ws_shutdown_timer=None,
+            )
         )
 
     def __str__(self):
@@ -1653,6 +1655,29 @@ class SubtensorInterface:
 
         return SubnetHyperparameters.from_any(result)
 
+    async def get_next_epoch_start_block(
+        self, netuid: int, block_hash: Optional[str] = None
+    ) -> Optional[int]:
+        """
+        Returns the block number at which the subnet's next epoch is expected to fire,
+        considering both the automatic schedule and any pending owner-triggered epoch.
+        It does not account for per-block epoch-cap deferrals, which can push the
+        actual firing block slightly later.
+
+        Returns `None` if the subnet does not run epochs (tempo == 0) or if the chain
+        does not expose the runtime API (runtimes without dynamic tempo).
+        """
+        try:
+            result = await self.query_runtime_api(
+                runtime_api="SubnetInfoRuntimeApi",
+                method="get_next_epoch_start_block",
+                params=[netuid],
+                block_hash=block_hash,
+            )
+        except (ValueError, SubstrateRequestException):
+            return None
+        return None if result is None else int(result)
+
     async def get_subnet_mechanisms(
         self, netuid: int, block_hash: Optional[str] = None
     ) -> int:
@@ -2680,7 +2705,7 @@ class SubtensorInterface:
         for idx, (_, result) in enumerate(batch_claimable):
             hotkey = unique_hotkeys[idx]
             if result:
-                for netuid, rate in result:
+                for netuid, rate in result.items():
                     if hotkey not in claimable_rates:
                         claimable_rates[hotkey] = {}
                     claimable_rates[hotkey][netuid] = fixed_to_float(rate, frac_bits=32)

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/bittensor/utils.py

@@ -855,6 +855,8 @@ def normalize_hyperparameters(
         "min_childkey_take": u16_normalized_float,
         "min_burn": Balance.from_rao,
         "max_burn": Balance.from_rao,
+        # Per-mille of tempo; normalized to the factor itself (1.0 = one full tempo).
+        "activity_cutoff_factor": lambda value: value / 1000,
     }
 
     normalized_values: list[tuple[str, str, str]] = []

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -42,15 +42,25 @@ async def get_childkey_completion_block(
     tempo_query = subtensor.get_hyperparameter(
         param_name="Tempo", netuid=netuid, block_hash=bh
     )
-    block_number, blocks_since_last_step, tempo = await asyncio.gather(
+    block_number, blocks_since_last_step, tempo, next_epoch = await asyncio.gather(
         subtensor.substrate.get_block_number(block_hash=bh),
         blocks_since_last_step_query,
         tempo_query,
+        subtensor.get_next_epoch_start_block(netuid, block_hash=bh),
     )
     cooldown = block_number + 7200
-    blocks_left_in_tempo = tempo - blocks_since_last_step
-    next_tempo = block_number + blocks_left_in_tempo
-    next_epoch_after_cooldown = (cooldown - next_tempo) % (tempo + 1) + cooldown
+    if next_epoch is not None and tempo:
+        # Dynamic-tempo scheduler: epochs fire at next_epoch, then every tempo blocks.
+        if next_epoch >= cooldown:
+            next_epoch_after_cooldown = next_epoch
+        else:
+            epochs_until_cooldown = (cooldown - next_epoch + tempo - 1) // tempo
+            next_epoch_after_cooldown = next_epoch + epochs_until_cooldown * tempo
+    else:
+        # Legacy modulo scheduler (chains without the dynamic-tempo runtime).
+        blocks_left_in_tempo = tempo - blocks_since_last_step
+        next_tempo = block_number + blocks_left_in_tempo
+        next_epoch_after_cooldown = (cooldown - next_tempo) % (tempo + 1) + cooldown
     return block_number, next_epoch_after_cooldown
 
 

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/commands/subnets/subnets.py

@@ -932,9 +932,10 @@ async def subnets_list(
                         subnet.blocks_since_last_step - prev_blocks_since_last_step
                     )
                 else:
-                    # Tempo restarted
+                    # Tempo restarted; the epoch period is exactly tempo blocks
+                    # under the dynamic-tempo scheduler.
                     block_change = (
-                        subnet.blocks_since_last_step + subnet.tempo + 1
+                        subnet.blocks_since_last_step + subnet.tempo
                     ) - prev_blocks_since_last_step
                 if block_change > 0:
                     block_change_text = f" [pale_green3](+{block_change})[/pale_green3]"

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/commands/sudo.py

@@ -14,6 +14,7 @@ from bittensor_cli.src import (
     HYPERPARAMS,
     HYPERPARAMS_MODULE,
     HYPERPARAMS_METADATA,
+    HYPERPARAMS_ROOT_EXTRINSIC,
     RootSudoOnly,
     COLOR_PALETTE,
 )
@@ -67,6 +68,15 @@ def allowed_value(
     """
     try:
         if not isinstance(value, bool):
+            if param == "activity_cutoff_factor":
+                # Bounds mirror MIN/MAX_ACTIVITY_CUTOFF_FACTOR_MILLI in subtensor.
+                factor = int(value)
+                if not 1_000 <= factor <= 50_000:
+                    return (
+                        False,
+                        "between 1000 and 50000 (per-mille units; 1000 = one full tempo)",
+                    )
+                return True, factor
             if param == "alpha_values":
                 # Split the string into individual values
                 alpha_low_str, alpha_high_str = value.split(",")
@@ -380,6 +390,7 @@ def search_metadata(
         "immunity_period": int,
         "commit_reveal_period": int,
         "adjustment_interval": int,
+        "factor_milli": int,
         "max_validators": int,
         "min_allowed_weights": int,
         "rho": int,
@@ -395,6 +406,7 @@ def search_metadata(
         "bool": string_to_bool,
         "u16": string_to_u16,
         "i16": string_to_i16,
+        "u32": int,
         "u64": string_to_u64,
         "MechId": int,
         "U64F64": string_to_u64f64,
@@ -404,6 +416,7 @@ def search_metadata(
         "bool": "bool",
         "u16": "float",
         "i16": "float (signed)",
+        "u32": "int",
         "u64": "float",
         "U64F64": "decimal",
         "TaoBalance": "Tao (float)",
@@ -598,13 +611,17 @@ async def set_hyperparameter_extrinsic(
     arbitrary_extrinsic = False
 
     extrinsic, sudo_ = HYPERPARAMS.get(parameter, ("", RootSudoOnly.FALSE))
+    # Resolve pallet and root-path override before `parameter` is potentially
+    # reassigned to the extrinsic name in normalize mode.
+    pallet = HYPERPARAMS_MODULE.get(parameter) or DEFAULT_PALLET
+    root_override = HYPERPARAMS_ROOT_EXTRINSIC.get(parameter)
     call_params = {"netuid": netuid}
     if normalize and parameter != "alpha_values":
         parameter = extrinsic
         extrinsic = None
     if not extrinsic:
         arbitrary_extrinsic, call_params = search_metadata(
-            parameter, value, netuid, subtensor.substrate.metadata
+            parameter, value, netuid, subtensor.substrate.metadata, pallet_name=pallet
         )
         extrinsic = parameter
         if not arbitrary_extrinsic:
@@ -624,7 +641,6 @@ async def set_hyperparameter_extrinsic(
 
     substrate = subtensor.substrate
     msg_value = value if not arbitrary_extrinsic else call_params
-    pallet = HYPERPARAMS_MODULE.get(parameter) or DEFAULT_PALLET
 
     if not arbitrary_extrinsic:
         extrinsic_params = await substrate.get_metadata_call_function(
@@ -665,13 +681,28 @@ async def set_hyperparameter_extrinsic(
         call_params=call_params,
         block_hash=block_hash,
     )
-    if sudo_ is RootSudoOnly.TRUE:
-        call = await substrate.compose_call(
+
+    async def sudo_wrapped() -> GenericCall:
+        # Root-sudo path: some hyperparams use a dedicated root extrinsic (e.g.
+        # AdminUtils.sudo_set_tempo) instead of Sudo-wrapping the owner call.
+        inner_call = call_
+        if root_override:
+            root_pallet, root_extrinsic = root_override
+            inner_call = await substrate.compose_call(
+                call_module=root_pallet,
+                call_function=root_extrinsic,
+                call_params=call_params,
+                block_hash=block_hash,
+            )
+        return await substrate.compose_call(
             call_module="Sudo",
             call_function="sudo",
-            call_params={"call": call_},
+            call_params={"call": inner_call},
             block_hash=block_hash,
         )
+
+    if sudo_ is RootSudoOnly.TRUE:
+        call = await sudo_wrapped()
     elif sudo_ is RootSudoOnly.COMPLICATED:
         if not prompt:
             # In no-prompt mode, owners should take the owner path; non-owners
@@ -684,12 +715,7 @@ async def set_hyperparameter_extrinsic(
                 quiet=quiet,
             )
         if to_sudo_or_not_to_sudo:
-            call = await substrate.compose_call(
-                call_module="Sudo",
-                call_function="sudo",
-                call_params={"call": call_},
-                block_hash=block_hash,
-            )
+            call = await sudo_wrapped()
         else:
             if subnet_owner != coldkey_ss58:
                 err_msg = "This wallet doesn't own the specified subnet."
@@ -1600,3 +1626,102 @@ async def trim(
             await print_extrinsic_id(ext_receipt)
             print_success(f"[dark_sea_green3]{msg}[/dark_sea_green3]")
         return True
+
+
+async def trigger_epoch(
+    wallet: Wallet,
+    subtensor: "SubtensorInterface",
+    netuid: int,
+    proxy: Optional[str],
+    period: int,
+    prompt: bool,
+    decline: bool,
+    quiet: bool,
+    json_output: bool,
+) -> bool:
+    """
+    Manually triggers an epoch for a subnet owned by the wallet.
+
+    The epoch is scheduled to fire after the chain's admin freeze window, during
+    which admin operations on the subnet are locked. Rate-limited on-chain, and
+    rejected if a trigger is already pending, the next automatic epoch is
+    imminent, or commit-reveal is enabled on the subnet.
+    """
+    coldkey_ss58 = proxy or wallet.coldkeypub.ss58_address
+    print_verbose("Confirming subnet owner")
+    block_hash = await subtensor.substrate.get_chain_head()
+    subnet_owner = await subtensor.query(
+        module="SubtensorModule",
+        storage_function="SubnetOwner",
+        params=[netuid],
+        block_hash=block_hash,
+    )
+    if subnet_owner != coldkey_ss58:
+        err_msg = "This wallet doesn't own the specified subnet."
+        if json_output:
+            json_console.print_json(data={"success": False, "message": err_msg})
+        else:
+            print_error(err_msg)
+        return False
+    if prompt and not json_output:
+        if not confirm_action(
+            f"You are about to manually trigger an epoch on SN{netuid}. "
+            f"This locks admin operations on the subnet until the epoch fires.",
+            default=False,
+            decline=decline,
+            quiet=quiet,
+        ):
+            print_error("User aborted.")
+            return False
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="trigger_epoch",
+        call_params={"netuid": netuid},
+        block_hash=block_hash,
+    )
+    with console.status(
+        f":satellite: Triggering epoch on subnet "
+        f"[{COLOR_PALETTE.G.SUBHEAD}]{netuid}[/{COLOR_PALETTE.G.SUBHEAD}] ...",
+        spinner="earth",
+    ):
+        success, err_msg, ext_receipt = await subtensor.sign_and_send_extrinsic(
+            call=call, wallet=wallet, era={"period": period}, proxy=proxy
+        )
+    if not success:
+        if json_output:
+            json_console.print_json(
+                data={
+                    "success": False,
+                    "message": err_msg,
+                    "extrinsic_identifier": None,
+                }
+            )
+        else:
+            print_error(err_msg)
+        return False
+    else:
+        ext_id = await ext_receipt.get_extrinsic_identifier()
+        fires_at = None
+        try:
+            for event in await ext_receipt.triggered_events:
+                if event["event_id"] == "EpochTriggered":
+                    fires_at = event["attributes"]["fires_at"]
+        except KeyError:
+            # The trigger still succeeded; the fires_at block is just a nice-to-have.
+            pass
+        msg = f"Epoch triggered on SN{netuid}"
+        if fires_at is not None:
+            msg += f"; it will fire at block {fires_at} at the earliest"
+        if json_output:
+            json_console.print_json(
+                data={
+                    "success": True,
+                    "message": msg,
+                    "fires_at": fires_at,
+                    "extrinsic_identifier": ext_id,
+                }
+            )
+        else:
+            await print_extrinsic_id(ext_receipt)
+            print_success(f"[dark_sea_green3]{msg}[/dark_sea_green3]")
+        return True

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/commands/wallets.py

@@ -1239,7 +1239,9 @@ async def overview(
             validator_trust = nn.validator_trust
             incentive = nn.incentive
             dividends = nn.dividends
-            emission = int(nn.emission / (subnet_tempo + 1) * 1e9)  # Per block
+            # Per block: the epoch period is exactly tempo blocks under the
+            # dynamic-tempo scheduler (guard against tempo == 0).
+            emission = int(nn.emission / max(subnet_tempo, 1) * 1e9)
             last_update = int(block - nn.last_update)
             validator_permit = nn.validator_permit
             row = [

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/bittensor_cli/src/commands/weights.py

@@ -152,10 +152,38 @@ class SetWeightsExtrinsic:
 
         return success, message, ext_id
 
+    async def _seconds_until_reveal(self, reveal_period: int) -> int:
+        """
+        Estimates the seconds until the reveal window opens. Commits made in epoch E
+        become revealable in epoch E + reveal_period, i.e. after the next epoch
+        boundary plus (reveal_period - 1) full tempos. Best-effort: owner tempo
+        changes, manually triggered epochs, or per-block epoch deferrals can shift
+        the actual boundary.
+        """
+        bh = await self.subtensor.substrate.get_chain_head()
+        current_block, tempo, next_epoch = await asyncio.gather(
+            self.subtensor.substrate.get_block_number(block_hash=bh),
+            self.subtensor.get_hyperparameter(
+                param_name="Tempo", netuid=self.netuid, block_hash=bh
+            ),
+            self.subtensor.get_next_epoch_start_block(self.netuid, block_hash=bh),
+        )
+        tempo = int(tempo)
+        if next_epoch is not None:
+            blocks_until_next_epoch = max(next_epoch - current_block, 0)
+        else:
+            # Legacy modulo scheduler (chains without the dynamic-tempo runtime).
+            remainder = (current_block + self.netuid + 1) % (tempo + 1)
+            blocks_until_next_epoch = (tempo + 1 - remainder) % (tempo + 1)
+        blocks_until_reveal = (
+            blocks_until_next_epoch + max(reveal_period - 1, 0) * tempo
+        )
+        return blocks_until_reveal * 12
+
     async def _commit_reveal(
         self, weight_uids: list[int], weight_vals: list[int]
     ) -> tuple[bool, str, Optional[str]]:
-        interval = int(
+        reveal_period = int(
             await self.subtensor.get_hyperparameter(
                 param_name="get_commit_reveal_period",
                 netuid=self.netuid,
@@ -174,6 +202,7 @@ class SetWeightsExtrinsic:
         )
 
         if commit_success:
+            interval = await self._seconds_until_reveal(reveal_period)
             current_time = datetime.now().astimezone().replace(microsecond=0)
             reveal_time = (current_time + timedelta(seconds=interval)).isoformat()
             cli_retry_cmd = f"--netuid {self.netuid} --uids {weight_uids} --weights {self.weights} --reveal-using-salt {self.salt}"

{bittensor_cli-9.23.0rc1 → bittensor_cli-9.23.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "bittensor-cli"
-version = "9.23.0rc1"
+version = "9.23.0rc2"
 description = "Bittensor CLI"
 readme = "README.md"
 authors = [