bittensor-cli 9.1.3__py3-none-any.whl → 9.2.0__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: "
@@ -286,10 +282,24 @@ async def stake_add(
                 return False
             remaining_wallet_balance -= amount_to_stake
 
-            # Calculate slippage
-            received_amount, slippage_pct, slippage_pct_float, rate = (
-                _calculate_slippage(subnet_info, amount_to_stake)
+            stake_fee = await subtensor.get_stake_fee(
+                origin_hotkey_ss58=None,
+                origin_netuid=None,
+                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                destination_hotkey_ss58=hotkey[1],
+                destination_netuid=netuid,
+                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                amount=amount_to_stake.rao,
             )
+
+            # Calculate slippage
+            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)
 
             # Add rows for the table
@@ -300,6 +310,7 @@ async def stake_add(
                 str(rate)
                 + f" {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",  # rate
                 str(received_amount.set_unit(netuid)),  # received
+                str(stake_fee),  # fee
                 str(slippage_pct),  # slippage
             ]
 
@@ -361,13 +372,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:
@@ -537,6 +546,11 @@ def _define_stake_table(
         justify="center",
         style=COLOR_PALETTE["POOLS"]["TAO_EQUIV"],
     )
+    table.add_column(
+        "Fee (τ)",
+        justify="center",
+        style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
+    )
     table.add_column(
         "Slippage", justify="center", style=COLOR_PALETTE["STAKE"]["SLIPPAGE_PERCENT"]
     )
@@ -590,28 +604,42 @@ 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, stake_fee: Balance
+) -> tuple[Balance, str, float, str]:
     """Calculate slippage when adding stake.
 
     Args:
         subnet_info: Subnet dynamic info
         amount: Amount being staked
+        stake_fee: Transaction fee for the stake operation
 
     Returns:
         tuple containing:
-        - received_amount: Amount received after slippage
+        - received_amount: Amount received after slippage and fees
         - slippage_str: Formatted slippage percentage string
         - slippage_float: Raw slippage percentage value
+        - rate: Exchange rate string
     """
-    received_amount, _, slippage_pct_float = subnet_info.tao_to_alpha_with_slippage(
-        amount
-    )
+    amount_after_fee = amount - stake_fee
+
+    if amount_after_fee < 0:
+        print_error("You don't have enough balance to cover the stake fee.")
+        raise ValueError()
+
+    received_amount, _, _ = subnet_info.tao_to_alpha_with_slippage(amount_after_fee)
+
     if subnet_info.is_dynamic:
+        ideal_amount = subnet_info.tao_to_alpha(amount)
+        total_slippage = ideal_amount - received_amount
+        slippage_pct_float = 100 * (total_slippage.tao / ideal_amount.tao)
         slippage_str = f"{slippage_pct_float:.4f} %"
         rate = f"{(1 / subnet_info.price.tao or 1):.4f}"
     else:
-        slippage_pct_float = 0
-        slippage_str = f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]N/A[/{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]"
+        slippage_pct_float = (
+            100 * float(stake_fee.tao) / float(amount.tao) if amount.tao != 0 else 0
+        )
+        slippage_str = f"{slippage_pct_float:.4f} %"
         rate = "1"
 
     return received_amount, slippage_str, slippage_pct_float, rate

bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -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(