bittensor-cli 9.20.1__tar.gz → 9.20.2rc1__tar.gz

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/PKG-INFO

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

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/bittensor_cli/src/__init__.py

@@ -609,7 +609,7 @@ HYPERPARAMS = {
         RootSudoOnly.TRUE,
     ),
     "min_burn": ("sudo_set_min_burn", RootSudoOnly.FALSE),
-    "max_burn": ("sudo_set_max_burn", RootSudoOnly.TRUE),
+    "max_burn": ("sudo_set_max_burn", RootSudoOnly.COMPLICATED),
     "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),
@@ -745,7 +745,7 @@ HYPERPARAMS_METADATA = {
     "max_burn": {
         "description": "Maximum TAO burn amount cap for subnet registration.",
         "side_effects": "Caps registration costs, ensuring registration remains accessible even as difficulty increases.",
-        "owner_settable": False,
+        "owner_settable": True,
         "docs_link": "docs.learnbittensor.org/subnets/subnet-hyperparameters#maxburn",
     },
     "bonds_moving_avg": {

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/bittensor_cli/src/commands/stake/add.py

@@ -339,13 +339,7 @@ async def stake_add(
             )
 
     # Determine the amount we are staking.
-    rows = []
-    amounts_to_stake = []
-    current_stake_balances = []
-    prices_with_tolerance = []
-    remaining_wallet_balance = current_wallet_balance
-    max_slippage = 0.0
-
+    operation_targets = []
     for hotkey in hotkeys_to_stake_to:
         for netuid in netuids:
             # Check that the subnet exists.
@@ -353,105 +347,126 @@ async def stake_add(
             if not subnet_info:
                 print_error(f"Subnet with netuid: {netuid} does not exist.")
                 continue
-            current_stake_balances.append(hotkey_stake_map[hotkey[1]][netuid])
-
-            # Get the amount.
-            amount_to_stake = Balance(0)
-            if amount:
-                amount_to_stake = Balance.from_tao(amount)
-            elif stake_all:
-                amount_to_stake = current_wallet_balance / len(netuids)
-            elif not amount:
-                amount_to_stake, _ = _prompt_stake_amount(
-                    current_balance=remaining_wallet_balance,
-                    netuid=netuid,
-                    action_name="stake",
-                )
-            amounts_to_stake.append(amount_to_stake)
+            operation_targets.append(
+                (hotkey, netuid, subnet_info, hotkey_stake_map[hotkey[1]][netuid])
+            )
 
-            # Check enough to stake.
-            if amount_to_stake > remaining_wallet_balance:
-                print_error(
-                    f"Not enough stake:[bold white]\n wallet balance:{remaining_wallet_balance} < "
-                    f"staking amount: {amount_to_stake}[/bold white]"
-                )
-                return
-            remaining_wallet_balance -= amount_to_stake
-
-            # Calculate slippage
-            # TODO: Update for V3, slippage calculation is significantly different in v3
-            # try:
-            #     received_amount, slippage_pct, slippage_pct_float, rate = (
-            #         _calculate_slippage(subnet_info, amount_to_stake, stake_fee)
-            #     )
-            # except ValueError:
-            #     return False
-            #
-            # max_slippage = max(slippage_pct_float, max_slippage)
-
-            # Temporary workaround - calculations without slippage
-            current_price_float = float(subnet_info.price.tao)
-            rate = _safe_inverse_rate(current_price_float)
-
-            # If we are staking safe, add price tolerance
-            if safe_staking:
-                if subnet_info.is_dynamic:
-                    price_with_tolerance = current_price_float * (1 + rate_tolerance)
-                    _rate_with_tolerance = _safe_inverse_rate(
-                        price_with_tolerance
-                    )  # Rate only for display
-                    rate_with_tolerance = f"{_rate_with_tolerance:.4f}"
-                    price_with_tolerance = Balance.from_tao(
-                        price_with_tolerance
-                    )  # Actual price to pass to extrinsic
-                else:
-                    rate_with_tolerance = "1"
-                    price_with_tolerance = Balance.from_rao(1)
-                extrinsic_fee = await get_stake_extrinsic_fee(
-                    netuid_=netuid,
-                    amount_=amount_to_stake,
-                    staking_address_=hotkey[1],
-                    safe_staking_=safe_staking,
-                    price_limit=price_with_tolerance,
-                )
-                prices_with_tolerance.append(price_with_tolerance)
-                row_extension = [
-                    f"{rate_with_tolerance} {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",
-                    f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]"
-                    # safe staking
-                    f"{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",
-                ]
+    if stake_all and not operation_targets:
+        print_error("No valid staking operations to perform.")
+        return
+
+    rows = []
+    operations = []
+    remaining_wallet_balance = current_wallet_balance
+    max_slippage = 0.0
+
+    for hotkey, netuid, subnet_info, current_stake_balance in operation_targets:
+        staking_address = hotkey[1]
+
+        # Get the amount.
+        amount_to_stake = Balance(0)
+        if amount:
+            amount_to_stake = Balance.from_tao(amount)
+        elif stake_all:
+            amount_to_stake = current_wallet_balance / len(operation_targets)
+        elif not amount:
+            amount_to_stake, _ = _prompt_stake_amount(
+                current_balance=remaining_wallet_balance,
+                netuid=netuid,
+                action_name="stake",
+            )
+
+        # Check enough to stake.
+        if amount_to_stake > remaining_wallet_balance:
+            print_error(
+                f"Not enough stake:[bold white]\n wallet balance:{remaining_wallet_balance} < "
+                f"staking amount: {amount_to_stake}[/bold white]"
+            )
+            return
+        remaining_wallet_balance -= amount_to_stake
+
+        # Calculate slippage
+        # TODO: Update for V3, slippage calculation is significantly different in v3
+        # try:
+        #     received_amount, slippage_pct, slippage_pct_float, rate = (
+        #         _calculate_slippage(subnet_info, amount_to_stake, stake_fee)
+        #     )
+        # except ValueError:
+        #     return False
+        #
+        # max_slippage = max(slippage_pct_float, max_slippage)
+
+        # Temporary workaround - calculations without slippage
+        current_price_float = float(subnet_info.price.tao)
+        rate = _safe_inverse_rate(current_price_float)
+        price_with_tolerance = None
+
+        # If we are staking safe, add price tolerance
+        if safe_staking:
+            if subnet_info.is_dynamic:
+                price_with_tolerance = current_price_float * (1 + rate_tolerance)
+                _rate_with_tolerance = _safe_inverse_rate(
+                    price_with_tolerance
+                )  # Rate only for display
+                rate_with_tolerance = f"{_rate_with_tolerance:.4f}"
+                price_with_tolerance = Balance.from_tao(
+                    price_with_tolerance
+                )  # Actual price to pass to extrinsic
             else:
-                extrinsic_fee = await get_stake_extrinsic_fee(
-                    netuid_=netuid,
-                    amount_=amount_to_stake,
-                    staking_address_=hotkey[1],
-                    safe_staking_=safe_staking,
-                )
-                row_extension = []
-            # TODO this should be asyncio gathered before the for loop
-            amount_minus_fee = (
-                (amount_to_stake - extrinsic_fee) if not proxy else amount_to_stake
+                rate_with_tolerance = "1"
+                price_with_tolerance = Balance.from_rao(1)
+            extrinsic_fee = await get_stake_extrinsic_fee(
+                netuid_=netuid,
+                amount_=amount_to_stake,
+                staking_address_=staking_address,
+                safe_staking_=safe_staking,
+                price_limit=price_with_tolerance,
+            )
+            row_extension = [
+                f"{rate_with_tolerance} {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",
+                f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]"
+                # safe staking
+                f"{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",
+            ]
+        else:
+            extrinsic_fee = await get_stake_extrinsic_fee(
+                netuid_=netuid,
+                amount_=amount_to_stake,
+                staking_address_=staking_address,
+                safe_staking_=safe_staking,
             )
-            sim_swap = await subtensor.sim_swap(
-                origin_netuid=0,
-                destination_netuid=netuid,
-                amount=amount_minus_fee.rao,
+            row_extension = []
+        # TODO this should be asyncio gathered before the for loop
+        amount_minus_fee = (
+            (amount_to_stake - extrinsic_fee) if not proxy else amount_to_stake
+        )
+        sim_swap = await subtensor.sim_swap(
+            origin_netuid=0,
+            destination_netuid=netuid,
+            amount=amount_minus_fee.rao,
+        )
+        received_amount = sim_swap.alpha_amount
+        # Add rows for the table
+        base_row = [
+            str(netuid),  # netuid
+            f"{staking_address}",  # hotkey
+            str(amount_to_stake),  # amount
+            str(rate) + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
+            str(received_amount.set_unit(netuid)),  # received
+            str(sim_swap.tao_fee),  # fee
+            str(extrinsic_fee),
+            # str(slippage_pct),  # slippage
+        ] + row_extension
+        rows.append(tuple(base_row))
+        operations.append(
+            (
+                netuid,
+                staking_address,
+                amount_to_stake,
+                current_stake_balance,
+                price_with_tolerance,
             )
-            received_amount = sim_swap.alpha_amount
-            # Add rows for the table
-            base_row = [
-                str(netuid),  # netuid
-                f"{hotkey[1]}",  # hotkey
-                str(amount_to_stake),  # amount
-                str(rate)
-                + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
-                str(received_amount.set_unit(netuid)),  # received
-                str(sim_swap.tao_fee),  # fee
-                str(extrinsic_fee),
-                # str(slippage_pct),  # slippage
-            ] + row_extension
-            rows.append(tuple(base_row))
+        )
 
     # Define and print stake table + slippage warning
     table = _define_stake_table(wallet, subtensor, safe_staking, rate_tolerance)
@@ -467,23 +482,6 @@ async def stake_add(
     if not unlock_key(wallet).success:
         return
 
-    # Build the list of (netuid, hotkey, amount, current_stake, price_limit) tuples
-    # that describe each staking operation we need to perform.
-    # The zip aligns netuids with amounts/balances (which are populated per
-    # hotkey-netuid pair, but the zip truncates to len(netuids), matching the
-    # original execution order). Each netuid's amount/price applies to all hotkeys.
-    operations = []
-    if safe_staking:
-        for ni, am, curr, price in zip(
-            netuids, amounts_to_stake, current_stake_balances, prices_with_tolerance
-        ):
-            for _, staking_address in hotkeys_to_stake_to:
-                operations.append((ni, staking_address, am, curr, price))
-    else:
-        for ni, am, curr in zip(netuids, amounts_to_stake, current_stake_balances):
-            for _, staking_address in hotkeys_to_stake_to:
-                operations.append((ni, staking_address, am, curr, None))
-
     total_ops = len(operations)
     use_batch = total_ops > 1
 

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/bittensor_cli/src/commands/sudo.py

@@ -614,7 +614,9 @@ async def set_hyperparameter_extrinsic(
         )
     elif sudo_ is RootSudoOnly.COMPLICATED:
         if not prompt:
-            to_sudo_or_not_to_sudo = True  # default to sudo true when no-prompt is set
+            # In no-prompt mode, owners should take the owner path; non-owners
+            # should default to sudo.
+            to_sudo_or_not_to_sudo = subnet_owner != coldkey_ss58
         else:
             to_sudo_or_not_to_sudo = confirm_action(
                 "This hyperparam can be executed as sudo or not. Do you want to execute as sudo [y] or not [n]?",

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/bittensor_cli/src/commands/wallets.py

@@ -1874,23 +1874,29 @@ async def swap_hotkey(
     return result
 
 
-def create_key_value_table(title: str = "Details") -> Table:
+def create_key_value_table(
+    title: str = "Details",
+    key_label: str = "Item",
+    value_label: str = "Value",
+) -> Table:
     """Creates a key-value table for displaying information for various cmds.
 
     Args:
         title: The title shown above the table.
+        key_label: The header for the key column.
+        value_label: The header for the value column.
 
     Returns:
         A Rich Table for key-value display.
     """
     return Table(
         Column(
-            "Item",
+            key_label,
             justify="right",
             style=COLOR_PALETTE["GENERAL"]["SUBHEADING_MAIN"],
             no_wrap=True,
         ),
-        Column("Value", style=COLOR_PALETTE["GENERAL"]["SUBHEADING"]),
+        Column(value_label, style=COLOR_PALETTE["GENERAL"]["SUBHEADING"]),
         title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]{title}",
         show_footer=True,
         show_edge=False,
@@ -2232,11 +2238,34 @@ async def announce_coldkey_swap(
                 return False
 
     # Proceed with the announcement
-    swap_cost, delay = await asyncio.gather(
+    swap_cost, delay, dest_staking_hotkeys = await asyncio.gather(
         subtensor.get_coldkey_swap_cost(block_hash=block_hash),
         subtensor.get_coldkey_swap_announcement_delay(block_hash=block_hash),
+        subtensor.get_staking_hotkeys(new_coldkey_ss58, block_hash=block_hash),
     )
 
+    if dest_staking_hotkeys:
+        print_error(
+            "Destination coldkey cannot have any staking hotkeys. "
+            "Please use a new coldkey for the swap."
+        )
+        identity_map = await subtensor.fetch_coldkey_hotkey_identities(
+            block_hash=block_hash
+        )
+        hk_table = create_key_value_table(
+            f"Staking Hotkeys Associated with Destination Coldkey \n Count: ({len(dest_staking_hotkeys)})\n",
+            key_label="Hotkey",
+            value_label="Identity",
+        )
+        for hk_ss58 in dest_staking_hotkeys:
+            hk_name = get_hotkey_identity_name(identity_map, hk_ss58) or "~"
+            hk_table.add_row(
+                f"[{COLORS.G.HK}]{hk_ss58}[/{COLORS.G.HK}]",
+                f"[{COLORS.G.CK}]{hk_name}[/{COLORS.G.CK}]",
+            )
+        console.print(hk_table)
+        return False
+
     table = create_key_value_table("Announcing Coldkey Swap\n")
     table.add_row(
         "Current Coldkey",

{bittensor_cli-9.20.1 → bittensor_cli-9.20.2rc1}/pyproject.toml

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