bittensor-cli 9.1.2__py3-none-any.whl → 9.1.4__py3-none-any.whl

bittensor_cli/src/commands/stake/add.py

@@ -46,9 +46,7 @@ async def stake_add(
         netuid: the netuid to stake to (None indicates all subnets)
         stake_all: whether to stake all available balance
         amount: specified amount of balance to stake
-        delegate: whether to delegate stake, currently unused
         prompt: whether to prompt the user
-        max_stake: maximum amount to stake (used in combination with stake_all), currently unused
         all_hotkeys: whether to stake all hotkeys
         include_hotkeys: list of hotkeys to include in staking process (if not specifying `--all`)
         exclude_hotkeys: list of hotkeys to exclude in staking (if specifying `--all`)
@@ -61,18 +59,16 @@ async def stake_add(
     """
 
     async def safe_stake_extrinsic(
-        netuid: int,
-        amount: Balance,
+        netuid_: int,
+        amount_: Balance,
         current_stake: Balance,
-        hotkey_ss58: str,
+        hotkey_ss58_: str,
         price_limit: Balance,
-        wallet: Wallet,
-        subtensor: "SubtensorInterface",
         status=None,
     ) -> None:
         err_out = partial(print_error, status=status)
         failure_prelude = (
-            f":cross_mark: [red]Failed[/red] to stake {amount} on Netuid {netuid}"
+            f":cross_mark: [red]Failed[/red] to stake {amount_} on Netuid {netuid_}"
         )
         current_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
         next_nonce = await subtensor.substrate.get_account_next_index(
@@ -82,9 +78,9 @@ async def stake_add(
             call_module="SubtensorModule",
             call_function="add_stake_limit",
             call_params={
-                "hotkey": hotkey_ss58,
-                "netuid": netuid,
-                "amount_staked": amount.rao,
+                "hotkey": hotkey_ss58_,
+                "netuid": netuid_,
+                "amount_staked": amount_.rao,
                 "limit_price": price_limit,
                 "allow_partial": allow_partial_stake,
             },
@@ -119,30 +115,30 @@ async def stake_add(
                 new_balance, new_stake = await asyncio.gather(
                     subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash),
                     subtensor.get_stake(
-                        hotkey_ss58=hotkey_ss58,
+                        hotkey_ss58=hotkey_ss58_,
                         coldkey_ss58=wallet.coldkeypub.ss58_address,
-                        netuid=netuid,
+                        netuid=netuid_,
                         block_hash=block_hash,
                     ),
                 )
                 console.print(
-                    f":white_heavy_check_mark: [dark_sea_green3]Finalized. Stake added to netuid: {netuid}[/dark_sea_green3]"
+                    f":white_heavy_check_mark: [dark_sea_green3]Finalized. Stake added to netuid: {netuid_}[/dark_sea_green3]"
                 )
                 console.print(
                     f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
                 )
 
                 amount_staked = current_balance - new_balance
-                if allow_partial_stake and (amount_staked != amount):
+                if allow_partial_stake and (amount_staked != amount_):
                     console.print(
                         "Partial stake transaction. Staked:\n"
                         f"  [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{amount_staked}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
                         f"instead of "
-                        f"[blue]{amount}[/blue]"
+                        f"[blue]{amount_}[/blue]"
                     )
 
                 console.print(
-                    f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
+                    f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid_}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
                     f"Stake:\n"
                     f"  [blue]{current_stake}[/blue] "
                     f":arrow_right: "
@@ -361,13 +357,11 @@ async def stake_add(
                 else:
                     stake_coroutines.append(
                         safe_stake_extrinsic(
-                            netuid=ni,
-                            amount=am,
+                            netuid_=ni,
+                            amount_=am,
                             current_stake=curr,
-                            hotkey_ss58=staking_address,
+                            hotkey_ss58_=staking_address,
                             price_limit=price_with_tolerance,
-                            wallet=wallet,
-                            subtensor=subtensor,
                         )
                     )
     else:
@@ -590,7 +584,9 @@ The columns are as follows:
     console.print(base_description + (safe_staking_description if safe_staking else ""))
 
 
-def _calculate_slippage(subnet_info, amount: Balance) -> tuple[Balance, str, float]:
+def _calculate_slippage(
+    subnet_info, amount: Balance
+) -> tuple[Balance, str, float, str]:
     """Calculate slippage when adding stake.
 
     Args:

bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -190,7 +190,7 @@ async def set_childkey_take_extrinsic(
         f":satellite: Setting childkey take on [white]{subtensor.network}[/white] ..."
     ):
         try:
-            if 0 < take <= 0.18:
+            if 0 <= take <= 0.18:
                 take_u16 = float_to_u16(take)
             else:
                 return False, "Invalid take value"
@@ -313,9 +313,12 @@ async def get_children(
         """
         Get the take value for a given subtensor, hotkey, and netuid.
 
-        @param child: The hotkey to retrieve the take value for.
+        Arguments:
+            child: The hotkey to retrieve the take value for.
+            netuid__: the netuid to retrieve the take value for.
 
-        @return: The take value as a float. If the take value is not available, it returns 0.
+        Returns:
+            The take value as a float. If the take value is not available, it returns 0.
 
         """
         child_hotkey = child[1]
@@ -383,7 +386,7 @@ async def get_children(
             f"The total stake of parent hotkey '{parent_hotkey}'{insert_text}is {parent_total}."
         )
 
-        for index, (netuid_, children_) in enumerate(netuid_children_):
+        for index, (child_netuid, children_) in enumerate(netuid_children_):
             # calculate totals
             total_proportion_per_netuid = 0
             total_stake_weight_per_netuid = 0
@@ -393,7 +396,7 @@ async def get_children(
 
             children_info = []
             child_takes = await asyncio.gather(
-                *[get_take(c, netuid_) for c in children_]
+                *[get_take(c, child_netuid) for c in children_]
             )
             for child, child_take in zip(children_, child_takes):
                 proportion = child[0]
@@ -408,7 +411,7 @@ async def get_children(
                     (
                         converted_proportion,
                         child_hotkey,
-                        hotkey_stake_dict[child_hotkey][netuid_],
+                        hotkey_stake_dict[child_hotkey][child_netuid],
                         child_take,
                     )
                 )
@@ -420,7 +423,7 @@ async def get_children(
             for proportion_, hotkey, stake, child_take in children_info:
                 proportion_percent = proportion_ * 100  # Proportion in percent
                 proportion_tao = (
-                    hotkey_stake[netuid_].tao * proportion_
+                    hotkey_stake[child_netuid].tao * proportion_
                 )  # Proportion in TAO
 
                 total_proportion_per_netuid += proportion_percent
@@ -433,7 +436,7 @@ async def get_children(
 
                 hotkey = Text(hotkey, style="italic red" if proportion_ == 0 else "")
                 table.add_row(
-                    str(netuid_),
+                    str(child_netuid),
                     hotkey,
                     proportion_str,
                     take_str,
@@ -661,28 +664,28 @@ async def childkey_take(
         table.add_column("Netuid", justify="center", style="cyan")
         table.add_column("Take (%)", justify="right", style="magenta")
 
-        for netuid, take_value in takes:
-            table.add_row(str(netuid), f"{take_value:.2f}%")
+        for take_netuid, take_value in takes:
+            table.add_row(str(take_netuid), f"{take_value:.2f}%")
 
         console.print(table)
 
-    async def display_chk_take(ss58, netuid):
+    async def display_chk_take(ss58, take_netuid):
         """Print single key take for hotkey and netuid"""
         chk_take = await get_childkey_take(
-            subtensor=subtensor, netuid=netuid, hotkey=ss58
+            subtensor=subtensor, netuid=take_netuid, hotkey=ss58
         )
         if chk_take is None:
             chk_take = 0
         chk_take = u16_to_float(chk_take)
         console.print(
-            f"Child take for {ss58} is: {chk_take * 100:.2f}% on netuid {netuid}."
+            f"Child take for {ss58} is: {chk_take * 100:.2f}% on netuid {take_netuid}."
         )
 
     async def chk_all_subnets(ss58):
         """Aggregate data for childkey take from all subnets"""
-        netuids = await subtensor.get_all_subnet_netuids()
+        all_netuids = await subtensor.get_all_subnet_netuids()
         takes = []
-        for subnet in netuids:
+        for subnet in all_netuids:
             if subnet == 0:
                 continue
             curr_take = await get_childkey_take(

bittensor_cli/src/commands/stake/list.py

@@ -34,38 +34,37 @@ async def stake_list(
 ):
     coldkey_address = coldkey_ss58 if coldkey_ss58 else wallet.coldkeypub.ss58_address
 
-    async def get_stake_data(block_hash: str = None):
+    async def get_stake_data(block_hash_: str = None):
         (
-            sub_stakes,
-            registered_delegate_info,
+            sub_stakes_,
+            registered_delegate_info_,
             _dynamic_info,
         ) = await asyncio.gather(
             subtensor.get_stake_for_coldkey(
-                coldkey_ss58=coldkey_address, block_hash=block_hash
+                coldkey_ss58=coldkey_address, block_hash=block_hash_
             ),
-            subtensor.get_delegate_identities(block_hash=block_hash),
-            subtensor.all_subnets(block_hash=block_hash),
+            subtensor.get_delegate_identities(block_hash=block_hash_),
+            subtensor.all_subnets(block_hash=block_hash_),
         )
         # sub_stakes = substakes[coldkey_address]
-        dynamic_info = {info.netuid: info for info in _dynamic_info}
+        dynamic_info__ = {info.netuid: info for info in _dynamic_info}
         return (
-            sub_stakes,
-            registered_delegate_info,
-            dynamic_info,
+            sub_stakes_,
+            registered_delegate_info_,
+            dynamic_info__,
         )
 
     def define_table(
-        hotkey_name: str,
+        hotkey_name_: str,
         rows: list[list[str]],
-        total_tao_value: Balance,
-        total_swapped_tao_value: Balance,
-        live: bool = False,
+        total_tao_value_: Balance,
+        total_swapped_tao_value_: Balance,
     ):
-        title = f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Hotkey: {hotkey_name}\nNetwork: {subtensor.network}\n\n"
+        title = f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Hotkey: {hotkey_name_}\nNetwork: {subtensor.network}\n\n"
         # TODO: Add hint back in after adding columns descriptions
         # if not live:
         #     title += f"[{COLOR_PALETTE['GENERAL']['HINT']}]See below for an explanation of the columns\n"
-        table = Table(
+        defined_table = Table(
             title=title,
             show_footer=True,
             show_edge=False,
@@ -76,74 +75,74 @@ async def stake_list(
             show_lines=False,
             pad_edge=True,
         )
-        table.add_column(
+        defined_table.add_column(
             "[white]Netuid",
             footer=f"{len(rows)}",
             footer_style="overline white",
             style="grey89",
         )
-        table.add_column(
+        defined_table.add_column(
             "[white]Name",
             style="cyan",
             justify="left",
             no_wrap=True,
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Value \n({Balance.get_unit(1)} x {Balance.unit}/{Balance.get_unit(1)})",
             footer_style="overline white",
             style=COLOR_PALETTE["STAKE"]["TAO"],
             justify="right",
-            footer=f"τ {millify_tao(total_tao_value.tao)}"
+            footer=f"τ {millify_tao(total_tao_value_.tao)}"
             if not verbose
-            else f"{total_tao_value}",
+            else f"{total_tao_value_}",
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Stake ({Balance.get_unit(1)})",
             footer_style="overline white",
             style=COLOR_PALETTE["STAKE"]["STAKE_ALPHA"],
             justify="center",
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Price \n({Balance.unit}_in/{Balance.get_unit(1)}_in)",
             footer_style="white",
             style=COLOR_PALETTE["POOLS"]["RATE"],
             justify="center",
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Swap ({Balance.get_unit(1)} -> {Balance.unit})",
             footer_style="overline white",
             style=COLOR_PALETTE["STAKE"]["STAKE_SWAP"],
             justify="right",
-            footer=f"τ {millify_tao(total_swapped_tao_value.tao)}"
+            footer=f"τ {millify_tao(total_swapped_tao_value_.tao)}"
             if not verbose
-            else f"{total_swapped_tao_value}",
+            else f"{total_swapped_tao_value_}",
         )
-        table.add_column(
+        defined_table.add_column(
             "[white]Registered",
             style=COLOR_PALETTE["STAKE"]["STAKE_ALPHA"],
             justify="right",
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Emission \n({Balance.get_unit(1)}/block)",
             style=COLOR_PALETTE["POOLS"]["EMISSION"],
             justify="right",
         )
-        table.add_column(
+        defined_table.add_column(
             f"[white]Emission \n({Balance.get_unit(0)}/block)",
             style=COLOR_PALETTE["POOLS"]["EMISSION"],
             justify="right",
         )
-        return table
+        return defined_table
 
     def create_table(hotkey_: str, substakes: list[StakeInfo]):
-        name = (
+        name_ = (
             f"{registered_delegate_info[hotkey_].display} ({hotkey_})"
             if hotkey_ in registered_delegate_info
             else hotkey_
         )
         rows = []
-        total_tao_value = Balance(0)
-        total_swapped_tao_value = Balance(0)
+        total_tao_value_ = Balance(0)
+        total_swapped_tao_value_ = Balance(0)
         root_stakes = [s for s in substakes if s.netuid == 0]
         other_stakes = sorted(
             [s for s in substakes if s.netuid != 0],
@@ -162,14 +161,14 @@ async def stake_list(
             alpha_value = Balance.from_rao(int(substake_.stake.rao)).set_unit(netuid)
 
             # TAO value cell
-            tao_value = pool.alpha_to_tao(alpha_value)
-            total_tao_value += tao_value
+            tao_value_ = pool.alpha_to_tao(alpha_value)
+            total_tao_value_ += tao_value_
 
             # Swapped TAO value and slippage cell
-            swapped_tao_value, _, slippage_percentage_ = (
+            swapped_tao_value_, _, slippage_percentage_ = (
                 pool.alpha_to_tao_with_slippage(substake_.stake)
             )
-            total_swapped_tao_value += swapped_tao_value
+            total_swapped_tao_value_ += swapped_tao_value_
 
             # Slippage percentage cell
             if pool.is_dynamic:
@@ -181,9 +180,9 @@ async def stake_list(
                 swap_value = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}] ({slippage_percentage})"
             else:
                 swap_value = (
-                    f"τ {millify_tao(swapped_tao_value.tao)} ({slippage_percentage})"
+                    f"τ {millify_tao(swapped_tao_value_.tao)} ({slippage_percentage})"
                     if not verbose
-                    else f"{swapped_tao_value} ({slippage_percentage})"
+                    else f"{swapped_tao_value_} ({slippage_percentage})"
                 )
 
             # Per block emission cell
@@ -202,9 +201,9 @@ async def stake_list(
                     [
                         str(netuid),  # Number
                         subnet_name_cell,  # Symbol + name
-                        f"τ {millify_tao(tao_value.tao)}"
+                        f"τ {millify_tao(tao_value_.tao)}"
                         if not verbose
-                        else f"{tao_value}",  # Value (α x τ/α)
+                        else f"{tao_value_}",  # Value (α x τ/α)
                         f"{stake_value} {symbol}"
                         if netuid != 0
                         else f"{symbol} {stake_value}",  # Stake (a)
@@ -221,27 +220,33 @@ async def stake_list(
                         str(Balance.from_tao(per_block_tao_emission)),
                     ]
                 )
-        table = define_table(name, rows, total_tao_value, total_swapped_tao_value)
+        created_table = define_table(
+            name_, rows, total_tao_value_, total_swapped_tao_value_
+        )
         for row in rows:
-            table.add_row(*row)
-        console.print(table)
-        return total_tao_value, total_swapped_tao_value
+            created_table.add_row(*row)
+        console.print(created_table)
+        return total_tao_value_, total_swapped_tao_value_
 
     def create_live_table(
         substakes: list,
-        registered_delegate_info: dict,
-        dynamic_info: dict,
-        hotkey_name: str,
-        previous_data: Optional[dict] = None,
-    ) -> tuple[Table, dict, Balance, Balance, Balance]:
+        dynamic_info_for_lt: dict,
+        hotkey_name_: str,
+        previous_data_: Optional[dict] = None,
+    ) -> tuple[Table, dict]:
         rows = []
-        current_data = {}
+        current_data_ = {}
 
-        total_tao_value = Balance(0)
-        total_swapped_tao_value = Balance(0)
+        total_tao_value_ = Balance(0)
+        total_swapped_tao_value_ = Balance(0)
 
         def format_cell(
-            value, previous_value, unit="", unit_first=False, precision=4, millify=False
+            value,
+            previous_value,
+            unit="",
+            unit_first_=False,
+            precision=4,
+            millify=False,
         ):
             if previous_value is not None:
                 change = value - previous_value
@@ -265,7 +270,7 @@ async def stake_list(
             )
             return (
                 f"{formatted_value} {unit}{change_text}"
-                if not unit_first
+                if not unit_first_
                 else f"{unit} {formatted_value}{change_text}"
             )
 
@@ -273,7 +278,7 @@ async def stake_list(
         root_stakes = [s for s in substakes if s.netuid == 0]
         other_stakes = sorted(
             [s for s in substakes if s.netuid != 0],
-            key=lambda x: dynamic_info[x.netuid]
+            key=lambda x: dynamic_info_for_lt[x.netuid]
             .alpha_to_tao(Balance.from_rao(int(x.stake.rao)).set_unit(x.netuid))
             .tao,
             reverse=True,
@@ -281,41 +286,41 @@ async def stake_list(
         sorted_substakes = root_stakes + other_stakes
 
         # Process each stake
-        for substake in sorted_substakes:
-            netuid = substake.netuid
-            pool = dynamic_info.get(netuid)
-            if substake.stake.rao == 0 or not pool:
+        for substake_ in sorted_substakes:
+            netuid = substake_.netuid
+            pool = dynamic_info_for_lt.get(netuid)
+            if substake_.stake.rao == 0 or not pool:
                 continue
 
             # Calculate base values
             symbol = f"{Balance.get_unit(netuid)}\u200e"
-            alpha_value = Balance.from_rao(int(substake.stake.rao)).set_unit(netuid)
-            tao_value = pool.alpha_to_tao(alpha_value)
-            total_tao_value += tao_value
-            swapped_tao_value, slippage, slippage_pct = pool.alpha_to_tao_with_slippage(
-                substake.stake
+            alpha_value = Balance.from_rao(int(substake_.stake.rao)).set_unit(netuid)
+            tao_value_ = pool.alpha_to_tao(alpha_value)
+            total_tao_value_ += tao_value_
+            swapped_tao_value_, slippage, slippage_pct = (
+                pool.alpha_to_tao_with_slippage(substake_.stake)
             )
-            total_swapped_tao_value += swapped_tao_value
+            total_swapped_tao_value_ += swapped_tao_value_
 
             # Store current values for future delta tracking
-            current_data[netuid] = {
+            current_data_[netuid] = {
                 "stake": alpha_value.tao,
                 "price": pool.price.tao,
-                "tao_value": tao_value.tao,
-                "swapped_value": swapped_tao_value.tao,
-                "emission": substake.emission.tao / (pool.tempo or 1),
-                "tao_emission": substake.tao_emission.tao / (pool.tempo or 1),
+                "tao_value": tao_value_.tao,
+                "swapped_value": swapped_tao_value_.tao,
+                "emission": substake_.emission.tao / (pool.tempo or 1),
+                "tao_emission": substake_.tao_emission.tao / (pool.tempo or 1),
             }
 
             # Get previous values for delta tracking
-            prev = previous_data.get(netuid, {}) if previous_data else {}
+            prev = previous_data_.get(netuid, {}) if previous_data_ else {}
             unit_first = True if netuid == 0 else False
 
             stake_cell = format_cell(
                 alpha_value.tao,
                 prev.get("stake"),
                 unit=symbol,
-                unit_first=unit_first,
+                unit_first_=unit_first,
                 precision=4,
                 millify=True if not verbose else False,
             )
@@ -324,16 +329,16 @@ async def stake_list(
                 pool.price.tao,
                 prev.get("price"),
                 unit=f"τ/{symbol}",
-                unit_first=False,
+                unit_first_=False,
                 precision=5,
                 millify=True if not verbose else False,
             )
 
             exchange_cell = format_cell(
-                tao_value.tao,
+                tao_value_.tao,
                 prev.get("tao_value"),
                 unit="τ",
-                unit_first=True,
+                unit_first_=True,
                 precision=4,
                 millify=True if not verbose else False,
             )
@@ -341,10 +346,10 @@ async def stake_list(
             if netuid != 0:
                 swap_cell = (
                     format_cell(
-                        swapped_tao_value.tao,
+                        swapped_tao_value_.tao,
                         prev.get("swapped_value"),
                         unit="τ",
-                        unit_first=True,
+                        unit_first_=True,
                         precision=4,
                         millify=True if not verbose else False,
                     )
@@ -353,27 +358,27 @@ async def stake_list(
             else:
                 swap_cell = f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]N/A[/{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}] ({slippage_pct}%)"
 
-            emission_value = substake.emission.tao / (pool.tempo or 1)
+            emission_value = substake_.emission.tao / (pool.tempo or 1)
             emission_cell = format_cell(
                 emission_value,
                 prev.get("emission"),
                 unit=symbol,
-                unit_first=unit_first,
+                unit_first_=unit_first,
                 precision=4,
             )
 
-            tao_emission_value = substake.tao_emission.tao / (pool.tempo or 1)
+            tao_emission_value = substake_.tao_emission.tao / (pool.tempo or 1)
             tao_emission_cell = format_cell(
                 tao_emission_value,
                 prev.get("tao_emission"),
                 unit="τ",
-                unit_first=unit_first,
+                unit_first_=unit_first,
                 precision=4,
             )
 
             subnet_name_cell = (
                 f"[{COLOR_PALETTE['GENERAL']['SYMBOL']}]{symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE['GENERAL']['SYMBOL']}]"
-                f" {get_subnet_name(dynamic_info[netuid])}"
+                f" {get_subnet_name(dynamic_info_for_lt[netuid])}"
             )
 
             rows.append(
@@ -385,25 +390,21 @@ async def stake_list(
                     rate_cell,  # Rate
                     swap_cell,  # Swap value with slippage
                     "YES"
-                    if substake.is_registered
+                    if substake_.is_registered
                     else f"[{COLOR_PALETTE['STAKE']['NOT_REGISTERED']}]NO",  # Registration status
                     emission_cell,  # Emission rate
                     tao_emission_cell,  # TAO emission rate
                 ]
             )
 
-        table = define_table(
-            hotkey_name,
-            rows,
-            total_tao_value,
-            total_swapped_tao_value,
-            live=True,
+        live_table = define_table(
+            hotkey_name_, rows, total_tao_value_, total_swapped_tao_value_
         )
 
         for row in rows:
-            table.add_row(*row)
+            live_table.add_row(*row)
 
-        return table, current_data
+        return live_table, current_data_
 
     # Main execution
     block_hash = await subtensor.substrate.get_chain_head()
@@ -448,10 +449,8 @@ async def stake_list(
                 choices=[str(i) for i in range(len(hotkeys_to_substakes))],
             )
             selected_hotkey = list(hotkeys_to_substakes.keys())[int(selected_idx)]
-            selected_stakes = hotkeys_to_substakes[selected_hotkey]
         else:
             selected_hotkey = list(hotkeys_to_substakes.keys())[0]
-            selected_stakes = hotkeys_to_substakes[selected_hotkey]
 
         hotkey_name = (
             f"{registered_delegate_info[selected_hotkey].display} ({selected_hotkey})"
@@ -499,7 +498,6 @@ async def stake_list(
 
                     table, current_data = create_live_table(
                         selected_stakes,
-                        registered_delegate_info,
                         dynamic_info_,
                         hotkey_name,
                         previous_data,

bittensor_cli/src/commands/stake/move.py

@@ -494,7 +494,6 @@ async def move_stake(
     )
 
     # Determine the amount we are moving.
-    amount_to_move_as_balance = None
     if amount:
         amount_to_move_as_balance = Balance.from_tao(amount)
     elif stake_all:
@@ -669,7 +668,6 @@ async def transfer_stake(
         )
         return False
 
-    amount_to_transfer = None
     if amount:
         amount_to_transfer = Balance.from_tao(amount).set_unit(origin_netuid)
     elif stake_all:
@@ -784,7 +782,6 @@ async def swap_stake(
     Args:
         wallet (Wallet): The wallet to swap stake from.
         subtensor (SubtensorInterface): Subtensor interface instance.
-        hotkey_ss58 (str): The SS58 address of the hotkey whose stake is being swapped.
         origin_netuid (int): The netuid from which stake is removed.
         destination_netuid (int): The netuid to which stake is added.
         amount (float): The amount to swap.