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

bittensor_cli/src/commands/stake/remove.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 from functools import partial
 
 from typing import TYPE_CHECKING, Optional
@@ -20,6 +21,7 @@ from bittensor_cli.src.bittensor.utils import (
     format_error_message,
     group_subnets,
     unlock_key,
+    json_console,
 )
 
 if TYPE_CHECKING:
@@ -41,6 +43,8 @@ async def unstake(
     safe_staking: bool,
     rate_tolerance: float,
     allow_partial_stake: bool,
+    json_output: bool,
+    era: int,
 ):
     """Unstake from hotkey(s)."""
     with console.status(
@@ -194,9 +198,25 @@ async def unstake(
                 )
                 continue  # Skip to the next subnet - useful when single amount is specified for all subnets
 
-            received_amount, slippage_pct, slippage_pct_float = _calculate_slippage(
-                subnet_info=subnet_info, amount=amount_to_unstake_as_balance
+            stake_fee = await subtensor.get_stake_fee(
+                origin_hotkey_ss58=staking_address_ss58,
+                origin_netuid=netuid,
+                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                destination_hotkey_ss58=None,
+                destination_netuid=None,
+                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                amount=amount_to_unstake_as_balance.rao,
             )
+
+            try:
+                received_amount, slippage_pct, slippage_pct_float = _calculate_slippage(
+                    subnet_info=subnet_info,
+                    amount=amount_to_unstake_as_balance,
+                    stake_fee=stake_fee,
+                )
+            except ValueError:
+                continue
+
             total_received_amount += received_amount
             max_float_slippage = max(max_float_slippage, slippage_pct_float)
 
@@ -220,6 +240,7 @@ async def unstake(
                 str(amount_to_unstake_as_balance),  # Amount to Unstake
                 str(subnet_info.price.tao)
                 + f"({Balance.get_unit(0)}/{Balance.get_unit(netuid)})",  # Rate
+                str(stake_fee),  # Fee
                 str(received_amount),  # Received Amount
                 slippage_pct,  # Slippage Percent
             ]
@@ -241,8 +262,11 @@ async def unstake(
                 base_unstake_op["price_with_tolerance"] = price_with_tolerance
                 base_table_row.extend(
                     [
-                        f"{rate_with_tolerance:.4f} {Balance.get_unit(0)}/{Balance.get_unit(netuid)}",  # Rate with tolerance
-                        f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",  # Partial unstake
+                        # Rate with tolerance
+                        f"{rate_with_tolerance:.4f} {Balance.get_unit(0)}/{Balance.get_unit(netuid)}",
+                        # Partial unstake
+                        f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]"
+                        f"{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",
                     ]
                 )
 
@@ -273,44 +297,45 @@ async def unstake(
     if not unlock_key(wallet).success:
         return False
 
+    successes = []
     with console.status("\n:satellite: Performing unstaking operations...") as status:
-        if safe_staking:
-            for op in unstake_operations:
-                if op["netuid"] == 0:
-                    await _unstake_extrinsic(
-                        wallet=wallet,
-                        subtensor=subtensor,
-                        netuid=op["netuid"],
-                        amount=op["amount_to_unstake"],
-                        current_stake=op["current_stake_balance"],
-                        hotkey_ss58=op["hotkey_ss58"],
-                        status=status,
-                    )
-                else:
-                    await _safe_unstake_extrinsic(
-                        wallet=wallet,
-                        subtensor=subtensor,
-                        netuid=op["netuid"],
-                        amount=op["amount_to_unstake"],
-                        hotkey_ss58=op["hotkey_ss58"],
-                        price_limit=op["price_with_tolerance"],
-                        allow_partial_stake=allow_partial_stake,
-                        status=status,
-                    )
-        else:
-            for op in unstake_operations:
-                await _unstake_extrinsic(
-                    wallet=wallet,
-                    subtensor=subtensor,
-                    netuid=op["netuid"],
-                    amount=op["amount_to_unstake"],
-                    current_stake=op["current_stake_balance"],
-                    hotkey_ss58=op["hotkey_ss58"],
-                    status=status,
-                )
+        for op in unstake_operations:
+            common_args = {
+                "wallet": wallet,
+                "subtensor": subtensor,
+                "netuid": op["netuid"],
+                "amount": op["amount_to_unstake"],
+                "hotkey_ss58": op["hotkey_ss58"],
+                "status": status,
+                "era": era,
+            }
+
+            if safe_staking and op["netuid"] != 0:
+                func = _safe_unstake_extrinsic
+                specific_args = {
+                    "price_limit": op["price_with_tolerance"],
+                    "allow_partial_stake": allow_partial_stake,
+                }
+            else:
+                func = _unstake_extrinsic
+                specific_args = {"current_stake": op["current_stake_balance"]}
+
+            suc = await func(**common_args, **specific_args)
+
+            successes.append(
+                {
+                    "netuid": op["netuid"],
+                    "hotkey_ss58": op["hotkey_ss58"],
+                    "unstake_amount": op["amount_to_unstake"].tao,
+                    "success": suc,
+                }
+            )
+
     console.print(
         f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]Unstaking operations completed."
     )
+    if json_output:
+        json_console.print(json.dumps(successes))
 
 
 async def unstake_all(
@@ -321,7 +346,9 @@ async def unstake_all(
     all_hotkeys: bool = False,
     include_hotkeys: Optional[list[str]] = None,
     exclude_hotkeys: Optional[list[str]] = None,
+    era: int = 3,
     prompt: bool = True,
+    json_output: bool = False,
 ) -> bool:
     """Unstakes all stakes from all hotkeys in all subnets."""
     include_hotkeys = include_hotkeys or []
@@ -412,7 +439,12 @@ async def unstake_all(
             style=COLOR_PALETTE["POOLS"]["RATE"],
         )
         table.add_column(
-            f"Recieved ({Balance.unit})",
+            f"Fee ({Balance.unit})",
+            justify="center",
+            style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
+        )
+        table.add_column(
+            f"Received ({Balance.unit})",
             justify="center",
             style=COLOR_PALETTE["POOLS"]["TAO_EQUIV"],
         )
@@ -432,9 +464,22 @@ async def unstake_all(
             hotkey_display = hotkey_names.get(stake.hotkey_ss58, stake.hotkey_ss58)
             subnet_info = all_sn_dynamic_info.get(stake.netuid)
             stake_amount = stake.stake
-            received_amount, slippage_pct, slippage_pct_float = _calculate_slippage(
-                subnet_info=subnet_info, amount=stake_amount
+            stake_fee = await subtensor.get_stake_fee(
+                origin_hotkey_ss58=stake.hotkey_ss58,
+                origin_netuid=stake.netuid,
+                origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                destination_hotkey_ss58=None,
+                destination_netuid=None,
+                destination_coldkey_ss58=wallet.coldkeypub.ss58_address,
+                amount=stake_amount.rao,
             )
+            try:
+                received_amount, slippage_pct, slippage_pct_float = _calculate_slippage(
+                    subnet_info=subnet_info, amount=stake_amount, stake_fee=stake_fee
+                )
+            except ValueError:
+                continue
+
             max_slippage = max(max_slippage, slippage_pct_float)
             total_received_value += received_amount
 
@@ -444,15 +489,21 @@ async def unstake_all(
                 str(stake_amount),
                 str(float(subnet_info.price))
                 + f"({Balance.get_unit(0)}/{Balance.get_unit(stake.netuid)})",
+                str(stake_fee),
                 str(received_amount),
                 slippage_pct,
             )
     console.print(table)
-    message = ""
     if max_slippage > 5:
-        message += f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]-------------------------------------------------------------------------------------------------------------------\n"
-        message += f"[bold]WARNING:[/bold] The slippage on one of your operations is high: [{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]{max_slippage:.4f}%[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}], this may result in a loss of funds.\n"
-        message += "-------------------------------------------------------------------------------------------------------------------\n"
+        message = (
+            f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_TEXT']}]--------------------------------------------------------------"
+            f"-----------------------------------------------------\n"
+            f"[bold]WARNING:[/bold] The slippage on one of your operations is high: "
+            f"[{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}]{max_slippage:.4f}%"
+            f"[/{COLOR_PALETTE['STAKE']['SLIPPAGE_PERCENT']}], this may result in a loss of funds.\n"
+            "----------------------------------------------------------------------------------------------------------"
+            "---------\n"
+        )
         console.print(message)
 
     console.print(
@@ -466,17 +517,20 @@ async def unstake_all(
 
     if not unlock_key(wallet).success:
         return False
-
+    successes = {}
     with console.status("Unstaking all stakes...") as status:
         for hotkey_ss58 in hotkey_ss58s:
-            await _unstake_all_extrinsic(
+            successes[hotkey_ss58] = await _unstake_all_extrinsic(
                 wallet=wallet,
                 subtensor=subtensor,
                 hotkey_ss58=hotkey_ss58,
                 hotkey_name=hotkey_names.get(hotkey_ss58, hotkey_ss58),
                 unstake_all_alpha=unstake_all_alpha,
                 status=status,
+                era=era,
             )
+    if json_output:
+        return json_console.print(json.dumps({"success": successes}))
 
 
 # Extrinsics
@@ -488,7 +542,8 @@ async def _unstake_extrinsic(
     current_stake: Balance,
     hotkey_ss58: str,
     status=None,
-) -> None:
+    era: int = 3,
+) -> bool:
     """Execute a standard unstake extrinsic.
 
     Args:
@@ -499,6 +554,7 @@ async def _unstake_extrinsic(
         wallet: Wallet instance
         subtensor: Subtensor interface
         status: Optional status for console updates
+        era: blocks for which the transaction is valid
     """
     err_out = partial(print_error, status=status)
     failure_prelude = (
@@ -510,33 +566,32 @@ async def _unstake_extrinsic(
             f"\n:satellite: Unstaking {amount} from {hotkey_ss58} on netuid: {netuid} ..."
         )
 
-    current_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
-    call = await subtensor.substrate.compose_call(
-        call_module="SubtensorModule",
-        call_function="remove_stake",
-        call_params={
-            "hotkey": hotkey_ss58,
-            "netuid": netuid,
-            "amount_unstaked": amount.rao,
-        },
+    current_balance, call = await asyncio.gather(
+        subtensor.get_balance(wallet.coldkeypub.ss58_address),
+        subtensor.substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="remove_stake",
+            call_params={
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+            },
+        ),
     )
     extrinsic = await subtensor.substrate.create_signed_extrinsic(
-        call=call, keypair=wallet.coldkey
+        call=call, keypair=wallet.coldkey, era={"period": era}
     )
 
     try:
         response = await subtensor.substrate.submit_extrinsic(
             extrinsic, wait_for_inclusion=True, wait_for_finalization=False
         )
-        await response.process_events()
-
         if not await response.is_success:
             err_out(
                 f"{failure_prelude} with error: "
                 f"{format_error_message(await response.error_message)}"
             )
-            return
-
+            return False
         # Fetch latest balance and stake
         block_hash = await subtensor.substrate.get_chain_head()
         new_balance, new_stake = await asyncio.gather(
@@ -557,9 +612,11 @@ async def _unstake_extrinsic(
             f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
             f" Stake:\n  [blue]{current_stake}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}"
         )
+        return True
 
     except Exception as e:
         err_out(f"{failure_prelude} with error: {str(e)}")
+        return False
 
 
 async def _safe_unstake_extrinsic(
@@ -571,7 +628,8 @@ async def _safe_unstake_extrinsic(
     price_limit: Balance,
     allow_partial_stake: bool,
     status=None,
-) -> None:
+    era: int = 3,
+) -> bool:
     """Execute a safe unstake extrinsic with price limit.
 
     Args:
@@ -596,30 +654,31 @@ async def _safe_unstake_extrinsic(
 
     block_hash = await subtensor.substrate.get_chain_head()
 
-    current_balance, next_nonce, current_stake = await asyncio.gather(
+    current_balance, next_nonce, current_stake, call = await asyncio.gather(
         subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash),
         subtensor.substrate.get_account_next_index(wallet.coldkeypub.ss58_address),
         subtensor.get_stake(
             hotkey_ss58=hotkey_ss58,
             coldkey_ss58=wallet.coldkeypub.ss58_address,
             netuid=netuid,
+            block_hash=block_hash,
+        ),
+        subtensor.substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="remove_stake_limit",
+            call_params={
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+                "limit_price": price_limit,
+                "allow_partial": allow_partial_stake,
+            },
+            block_hash=block_hash,
         ),
-    )
-
-    call = await subtensor.substrate.compose_call(
-        call_module="SubtensorModule",
-        call_function="remove_stake_limit",
-        call_params={
-            "hotkey": hotkey_ss58,
-            "netuid": netuid,
-            "amount_unstaked": amount.rao,
-            "limit_price": price_limit,
-            "allow_partial": allow_partial_stake,
-        },
     )
 
     extrinsic = await subtensor.substrate.create_signed_extrinsic(
-        call=call, keypair=wallet.coldkey, nonce=next_nonce
+        call=call, keypair=wallet.coldkey, nonce=next_nonce, era={"period": era}
     )
 
     try:
@@ -634,17 +693,15 @@ async def _safe_unstake_extrinsic(
                 f"Either increase price tolerance or enable partial unstaking.",
                 status=status,
             )
-            return
         else:
             err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
-        return
+        return False
 
-    await response.process_events()
     if not await response.is_success:
         err_out(
             f"\n{failure_prelude} with error: {format_error_message(await response.error_message)}"
         )
-        return
+        return False
 
     block_hash = await subtensor.substrate.get_chain_head()
     new_balance, new_stake = await asyncio.gather(
@@ -675,6 +732,7 @@ async def _safe_unstake_extrinsic(
         f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
         f"Stake:\n  [blue]{current_stake}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}"
     )
+    return True
 
 
 async def _unstake_all_extrinsic(
@@ -684,6 +742,7 @@ async def _unstake_all_extrinsic(
     hotkey_name: str,
     unstake_all_alpha: bool,
     status=None,
+    era: int = 3,
 ) -> None:
     """Execute an unstake all extrinsic.
 
@@ -734,13 +793,11 @@ async def _unstake_all_extrinsic(
     try:
         response = await subtensor.substrate.submit_extrinsic(
             extrinsic=await subtensor.substrate.create_signed_extrinsic(
-                call=call,
-                keypair=wallet.coldkey,
+                call=call, keypair=wallet.coldkey, era={"period": era}
             ),
             wait_for_inclusion=True,
             wait_for_finalization=False,
         )
-        await response.process_events()
 
         if not await response.is_success:
             err_out(
@@ -791,28 +848,47 @@ async def _unstake_all_extrinsic(
 
 
 # Helpers
-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]:
     """Calculate slippage and received amount for unstaking operation.
 
     Args:
         subnet_info: Subnet information containing price data
         amount: Amount being unstaked
+        stake_fee: Stake fee to include in slippage calculation
 
     Returns:
         tuple containing:
-        - received_amount: Balance after slippage
+        - received_amount: Balance after slippage deduction
         - slippage_pct: Formatted string of slippage percentage
         - slippage_pct_float: Float value of slippage percentage
     """
-    received_amount, _, slippage_pct_float = subnet_info.alpha_to_tao_with_slippage(
-        amount
-    )
+    received_amount, _, _ = subnet_info.alpha_to_tao_with_slippage(amount)
+    received_amount -= stake_fee
+
+    if received_amount < Balance.from_tao(0):
+        print_error("Not enough Alpha to pay the transaction fee.")
+        raise ValueError
 
     if subnet_info.is_dynamic:
+        # Ideal amount w/o slippage
+        ideal_amount = subnet_info.alpha_to_tao(amount)
+
+        # Total slippage including fees
+        total_slippage = ideal_amount - received_amount
+        slippage_pct_float = (
+            100 * (float(total_slippage.tao) / float(ideal_amount.tao))
+            if ideal_amount.tao != 0
+            else 0
+        )
         slippage_pct = f"{slippage_pct_float:.4f} %"
     else:
-        slippage_pct_float = 0
-        slippage_pct = "[red]N/A[/red]"
+        # Root will only have fee-based slippage
+        slippage_pct_float = (
+            100 * float(stake_fee.tao) / float(amount.tao) if amount.tao != 0 else 0
+        )
+        slippage_pct = f"{slippage_pct_float:.4f} %"
 
     return received_amount, slippage_pct, slippage_pct_float
 
@@ -1174,6 +1250,11 @@ def _create_unstake_table(
         justify="center",
         style=COLOR_PALETTE["POOLS"]["RATE"],
     )
+    table.add_column(
+        f"Fee ({Balance.get_unit(0)})",
+        justify="center",
+        style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
+    )
     table.add_column(
         f"Received ({Balance.get_unit(0)})",
         justify="center",
@@ -1227,7 +1308,8 @@ The columns are as follows:
     - [bold white]Hotkey[/bold white]: The ss58 address or identity of the hotkey you are unstaking from. 
     - [bold white]Amount to Unstake[/bold white]: The stake amount you are removing from this key.
     - [bold white]Rate[/bold white]: The rate of exchange between TAO and the subnet's stake.
-    - [bold white]Received[/bold white]: The amount of free balance TAO you will receive on this subnet after slippage.
+    - [bold white]Fee[/bold white]: The transaction fee for this unstake operation.
+    - [bold white]Received[/bold white]: The amount of free balance TAO you will receive on this subnet after slippage and fees.
     - [bold white]Slippage[/bold white]: The slippage percentage of the unstake operation. (0% if the subnet is not dynamic i.e. root)."""
 
     safe_staking_description = """

bittensor_cli/src/commands/subnets/price.py

@@ -13,6 +13,7 @@ from bittensor_cli.src.bittensor.utils import (
     err_console,
     get_subnet_name,
     print_error,
+    json_console,
 )
 
 if TYPE_CHECKING:
@@ -26,6 +27,7 @@ async def price(
     interval_hours: int = 24,
     html_output: bool = False,
     log_scale: bool = False,
+    json_output: bool = False,
 ):
     """
     Fetch historical price data for subnets and display it in a chart.
@@ -60,7 +62,7 @@ async def price(
         all_subnet_infos = await asyncio.gather(*subnet_info_cors)
 
         subnet_data = _process_subnet_data(
-            block_numbers, all_subnet_infos, netuids, all_netuids, interval_hours
+            block_numbers, all_subnet_infos, netuids, all_netuids
         )
 
     if not subnet_data:
@@ -71,17 +73,13 @@ async def price(
         await _generate_html_output(
             subnet_data, block_numbers, interval_hours, log_scale
         )
+    elif json_output:
+        json_console.print(json.dumps(_generate_json_output(subnet_data)))
     else:
         _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale)
 
 
-def _process_subnet_data(
-    block_numbers,
-    all_subnet_infos,
-    netuids,
-    all_netuids,
-    interval_hours,
-):
+def _process_subnet_data(block_numbers, all_subnet_infos, netuids, all_netuids):
     """
     Process subnet data into a structured format for price analysis.
     """
@@ -772,6 +770,10 @@ async def _generate_html_output(
         print_error(f"Error generating price chart: {e}")
 
 
+def _generate_json_output(subnet_data):
+    return {netuid: data for netuid, data in subnet_data.items()}
+
+
 def _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale):
     """
     Render the price data in a textual CLI style with plotille ASCII charts.
@@ -802,7 +804,7 @@ def _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale):
 
         fig.plot(
             block_numbers,
-            data["prices"],
+            prices,
             label=f"Subnet {netuid} Price",
             interp="linear",
             lc="bae98f",