bittensor-cli 9.8.7__py3-none-any.whl → 9.10.0__py3-none-any.whl

bittensor_cli/src/commands/stake/remove.py

@@ -22,6 +22,7 @@ from bittensor_cli.src.bittensor.utils import (
     group_subnets,
     unlock_key,
     json_console,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -47,6 +48,7 @@ async def unstake(
     era: int,
 ):
     """Unstake from hotkey(s)."""
+
     with console.status(
         f"Retrieving subnet data & identities from {subtensor.network}...",
         spinner="earth",
@@ -82,7 +84,7 @@ async def unstake(
             hotkey_to_unstake_all = hotkeys_to_unstake_from[0]
             unstake_all_alpha = Confirm.ask(
                 "\nDo you want to:\n"
-                "[blue]Yes[/blue]: Unstake from all subnets and automatically restake to subnet 0 (root)\n"
+                "[blue]Yes[/blue]: Unstake from all subnets and automatically re-stake to subnet 0 (root)\n"
                 "[blue]No[/blue]: Unstake everything (including subnet 0)",
                 default=True,
             )
@@ -210,8 +212,38 @@ async def unstake(
 
             try:
                 current_price = subnet_info.price.tao
+                if safe_staking:
+                    if subnet_info.is_dynamic:
+                        price_with_tolerance = current_price * (1 - rate_tolerance)
+                        rate_with_tolerance = price_with_tolerance
+                        price_limit = Balance.from_tao(
+                            rate_with_tolerance
+                        )  # Actual price to pass to extrinsic
+                    else:
+                        price_limit = Balance.from_rao(1)
+                    extrinsic_fee = await _get_extrinsic_fee(
+                        "unstake_safe",
+                        wallet,
+                        subtensor,
+                        hotkey_ss58=staking_address_ss58,
+                        amount=amount_to_unstake_as_balance,
+                        netuid=netuid,
+                        price_limit=price_limit,
+                        allow_partial_stake=allow_partial_stake,
+                    )
+                else:
+                    extrinsic_fee = await _get_extrinsic_fee(
+                        "unstake",
+                        wallet,
+                        subtensor,
+                        hotkey_ss58=staking_address_ss58,
+                        netuid=netuid,
+                        amount=amount_to_unstake_as_balance,
+                    )
                 rate = current_price
-                received_amount = amount_to_unstake_as_balance * rate
+                received_amount = (
+                    (amount_to_unstake_as_balance - stake_fee) * rate
+                ) - extrinsic_fee
             except ValueError:
                 continue
             total_received_amount += received_amount
@@ -233,8 +265,9 @@ async def unstake(
                 staking_address_name,  # Hotkey Name
                 str(amount_to_unstake_as_balance),  # Amount to Unstake
                 f"{subnet_info.price.tao:.6f}"
-                + f"({Balance.get_unit(0)}/{Balance.get_unit(netuid)})",  # Rate
+                + f"(τ/{Balance.get_unit(netuid)})",  # Rate
                 str(stake_fee.set_unit(netuid)),  # Fee
+                str(extrinsic_fee),  # Extrinsic fee
                 str(received_amount),  # Received Amount
                 # slippage_pct,  # Slippage Percent
             ]
@@ -375,7 +408,7 @@ async def unstake_all(
                 old_identities=old_identities,
             )
         elif not hotkey_ss58_address:
-            hotkeys = [(wallet.hotkey_str, wallet.hotkey.ss58_address, None)]
+            hotkeys = [(wallet.hotkey_str, get_hotkey_pub_ss58(wallet), None)]
         else:
             hotkeys = [(None, hotkey_ss58_address, None)]
 
@@ -431,10 +464,15 @@ async def unstake_all(
             style=COLOR_PALETTE["POOLS"]["RATE"],
         )
         table.add_column(
-            f"Fee ({Balance.unit})",
+            f"Fee ({Balance.get_unit(1)})",
             justify="center",
             style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
         )
+        table.add_column(
+            "Extrinsic Fee (τ)",
+            justify="center",
+            style=COLOR_PALETTE.STAKE.TAO,
+        )
         table.add_column(
             f"Received ({Balance.unit})",
             justify="center",
@@ -467,8 +505,17 @@ async def unstake_all(
 
             try:
                 current_price = subnet_info.price.tao
+                extrinsic_type = (
+                    "unstake_all" if not unstake_all_alpha else "unstake_all_alpha"
+                )
+                extrinsic_fee = await _get_extrinsic_fee(
+                    extrinsic_type,
+                    wallet,
+                    subtensor,
+                    hotkey_ss58=stake.hotkey_ss58,
+                )
                 rate = current_price
-                received_amount = stake_amount * rate - stake_fee
+                received_amount = ((stake_amount - stake_fee) * rate) - extrinsic_fee
 
                 if received_amount < Balance.from_tao(0):
                     print_error("Not enough Alpha to pay the transaction fee.")
@@ -485,6 +532,7 @@ async def unstake_all(
                 f"{float(subnet_info.price):.6f}"
                 + f"({Balance.get_unit(0)}/{Balance.get_unit(stake.netuid)})",
                 str(stake_fee),
+                str(extrinsic_fee),
                 str(received_amount),
             )
     console.print(table)
@@ -830,6 +878,63 @@ async def _unstake_all_extrinsic(
         err_out(f"{failure_prelude} with error: {str(e)}")
 
 
+async def _get_extrinsic_fee(
+    _type: str,
+    wallet: Wallet,
+    subtensor: "SubtensorInterface",
+    hotkey_ss58: str,
+    netuid: Optional[int] = None,
+    amount: Optional[Balance] = None,
+    price_limit: Optional[Balance] = None,
+    allow_partial_stake: bool = False,
+) -> Balance:
+    """
+    Retrieves the extrinsic fee for a given unstaking call.
+    Args:
+        _type: 'unstake', 'unstake_safe', 'unstake_all', 'unstake_all_alpha' depending on the specific
+            extrinsic to be called
+        wallet: Wallet object
+        subtensor: SubtensorInterface object
+        hotkey_ss58: the hotkey ss58 to unstake from
+        netuid: the netuid from which to remove the stake
+        amount: the amount of stake to remove
+        price_limit: the price limit
+        allow_partial_stake: whether to allow partial unstaking
+
+    Returns:
+        Balance object representing the extrinsic fee.
+    """
+    lookup_table = {
+        "unstake": lambda: (
+            "remove_stake",
+            {
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+            },
+        ),
+        "unstake_safe": lambda: (
+            "remove_stake_limit",
+            {
+                "hotkey": hotkey_ss58,
+                "netuid": netuid,
+                "amount_unstaked": amount.rao,
+                "limit_price": price_limit,
+                "allow_partial": allow_partial_stake,
+            },
+        ),
+        "unstake_all": lambda: ("unstake_all", {"hotkey": hotkey_ss58}),
+        "unstake_all_alpha": lambda: ("unstake_all_alpha", {"hotkey": hotkey_ss58}),
+    }
+    call_fn, call_params = lookup_table[_type]()
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function=call_fn,
+        call_params=call_params,
+    )
+    return await subtensor.get_extrinsic_fee(call, wallet.coldkeypub)
+
+
 # Helpers
 async def _unstake_selection(
     dynamic_info,
@@ -1094,7 +1199,7 @@ def _get_hotkeys_to_unstake(
         print_verbose("Unstaking from all hotkeys")
         all_hotkeys_ = get_hotkey_wallets_for_wallet(wallet=wallet)
         wallet_hotkeys = [
-            (wallet.hotkey_str, wallet.hotkey.ss58_address, None)
+            (wallet.hotkey_str, get_hotkey_pub_ss58(wallet), None)
             for wallet in all_hotkeys_
             if wallet.hotkey_str not in exclude_hotkeys
         ]
@@ -1126,7 +1231,7 @@ def _get_hotkeys_to_unstake(
                     path=wallet.path,
                     hotkey=hotkey_identifier,
                 )
-                result.append((wallet_.hotkey_str, wallet_.hotkey.ss58_address, None))
+                result.append((wallet_.hotkey_str, get_hotkey_pub_ss58(wallet_), None))
         return result
 
     # Only cli.config.wallet.hotkey is specified
@@ -1134,7 +1239,7 @@ def _get_hotkeys_to_unstake(
         f"Unstaking from wallet: ({wallet.name}) from hotkey: ({wallet.hotkey_str})"
     )
     assert wallet.hotkey is not None
-    return [(wallet.hotkey_str, wallet.hotkey.ss58_address, None)]
+    return [(wallet.hotkey_str, get_hotkey_pub_ss58(wallet), None)]
 
 
 def _create_unstake_table(
@@ -1184,7 +1289,7 @@ def _create_unstake_table(
         style=COLOR_PALETTE["POOLS"]["TAO"],
     )
     table.add_column(
-        f"Rate ({Balance.get_unit(0)}/{Balance.get_unit(1)})",
+        f"Rate (τ/{Balance.get_unit(1)})",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["RATE"],
     )
@@ -1194,7 +1299,10 @@ def _create_unstake_table(
         style=COLOR_PALETTE["STAKE"]["STAKE_AMOUNT"],
     )
     table.add_column(
-        f"Received ({Balance.get_unit(0)})",
+        "Extrinsic Fee (τ)", justify="center", style=COLOR_PALETTE.STAKE.TAO
+    )
+    table.add_column(
+        "Received (τ)",
         justify="center",
         style=COLOR_PALETTE["POOLS"]["TAO_EQUIV"],
         footer=str(total_received_amount),

bittensor_cli/src/commands/subnets/price.py

@@ -10,6 +10,7 @@ import plotille
 import plotly.graph_objects as go
 
 from bittensor_cli.src import COLOR_PALETTE
+from bittensor_cli.src.bittensor.chain_data import DynamicInfo
 from bittensor_cli.src.bittensor.utils import (
     console,
     err_console,
@@ -27,7 +28,8 @@ async def price(
     subtensor: "SubtensorInterface",
     netuids: list[int],
     all_netuids: bool = False,
-    interval_hours: int = 24,
+    interval_hours: int = 4,
+    current_only: bool = False,
     html_output: bool = False,
     log_scale: bool = False,
     json_output: bool = False,
@@ -41,45 +43,96 @@ async def price(
     blocks_per_hour = int(3600 / 12)  # ~300 blocks per hour
     total_blocks = blocks_per_hour * interval_hours
 
-    with console.status(":chart_increasing: Fetching historical price data..."):
-        current_block_hash = await subtensor.substrate.get_chain_head()
-        current_block = await subtensor.substrate.get_block_number(current_block_hash)
+    if not current_only:
+        with console.status(":chart_increasing: Fetching historical price data..."):
+            current_block_hash = await subtensor.substrate.get_chain_head()
+            current_block = await subtensor.substrate.get_block_number(
+                current_block_hash
+            )
 
-        step = 300
-        start_block = max(0, current_block - total_blocks)
-        block_numbers = list(range(start_block, current_block + 1, step))
+            step = 300
+            start_block = max(0, current_block - total_blocks)
+            block_numbers = list(range(start_block, current_block + 1, step))
 
-        # Block hashes
-        block_hash_cors = [
-            subtensor.substrate.get_block_hash(bn) for bn in block_numbers
-        ]
-        block_hashes = await asyncio.gather(*block_hash_cors)
+            # Block hashes
+            block_hash_cors = [
+                subtensor.substrate.get_block_hash(bn) for bn in block_numbers
+            ]
+            block_hashes = await asyncio.gather(*block_hash_cors)
 
-        # We fetch all subnets when there is more than one netuid
-        if all_netuids or len(netuids) > 1:
-            subnet_info_cors = [subtensor.all_subnets(bh) for bh in block_hashes]
-        else:
-            # If there is only one netuid, we fetch the subnet info for that netuid
-            netuid = netuids[0]
-            subnet_info_cors = [subtensor.subnet(netuid, bh) for bh in block_hashes]
-        all_subnet_infos = await asyncio.gather(*subnet_info_cors)
+            # We fetch all subnets when there is more than one netuid
+            if all_netuids or len(netuids) > 1:
+                subnet_info_cors = [subtensor.all_subnets(bh) for bh in block_hashes]
+            else:
+                # If there is only one netuid, we fetch the subnet info for that netuid
+                netuid = netuids[0]
+                subnet_info_cors = [subtensor.subnet(netuid, bh) for bh in block_hashes]
+            all_subnet_infos = await asyncio.gather(*subnet_info_cors)
 
         subnet_data = _process_subnet_data(
             block_numbers, all_subnet_infos, netuids, all_netuids
         )
+        if not subnet_data:
+            err_console.print("[red]No valid price data found for any subnet[/red]")
+            return
 
-    if not subnet_data:
-        err_console.print("[red]No valid price data found for any subnet[/red]")
-        return
-
-    if html_output:
-        await _generate_html_output(
-            subnet_data, block_numbers, interval_hours, log_scale
+        if html_output:
+            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)
+    else:
+        with console.status("Fetching current price data..."):
+            if all_netuids or len(netuids) > 1:
+                all_subnet_info = await subtensor.all_subnets()
+            else:
+                all_subnet_info = [await subtensor.subnet(netuid=netuids[0])]
+        subnet_data = _process_current_subnet_data(
+            all_subnet_info, netuids, all_netuids
         )
-    elif json_output:
-        json_console.print(json.dumps(_generate_json_output(subnet_data)))
+        if json_output:
+            json_console.print(json.dumps(_generate_json_output(subnet_data)))
+        else:
+            _generate_cli_output_current(subnet_data)
+
+
+def _process_current_subnet_data(subnet_infos: list[DynamicInfo], netuids, all_netuids):
+    subnet_data = {}
+    if all_netuids or len(netuids) > 1:
+        # Most recent data for statistics
+        for subnet_info in subnet_infos:
+            stats = {
+                "current_price": subnet_info.price,
+                "supply": subnet_info.alpha_in.tao + subnet_info.alpha_out.tao,
+                "market_cap": subnet_info.price.tao
+                * (subnet_info.alpha_in.tao + subnet_info.alpha_out.tao),
+                "emission": subnet_info.emission.tao,
+                "stake": subnet_info.alpha_out.tao,
+                "symbol": subnet_info.symbol,
+                "name": get_subnet_name(subnet_info),
+            }
+            subnet_data[subnet_info.netuid] = {
+                "stats": stats,
+            }
     else:
-        _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale)
+        subnet_info = subnet_infos[0]
+        stats = {
+            "current_price": subnet_info.price.tao,
+            "supply": subnet_info.alpha_in.tao + subnet_info.alpha_out.tao,
+            "market_cap": subnet_info.price.tao
+            * (subnet_info.alpha_in.tao + subnet_info.alpha_out.tao),
+            "emission": subnet_info.emission.tao,
+            "stake": subnet_info.alpha_out.tao,
+            "symbol": subnet_info.symbol,
+            "name": get_subnet_name(subnet_info),
+        }
+        subnet_data[subnet_info.netuid] = {
+            "stats": stats,
+        }
+    return subnet_data
 
 
 def _process_subnet_data(block_numbers, all_subnet_infos, netuids, all_netuids):
@@ -626,3 +679,46 @@ def _generate_cli_output(subnet_data, block_numbers, interval_hours, log_scale):
             )
 
         console.print(stats_text)
+
+
+def _generate_cli_output_current(subnet_data):
+    for netuid, data in subnet_data.items():
+        stats = data["stats"]
+
+        if netuid != 0:
+            console.print(
+                f"\n[{COLOR_PALETTE.G.SYM}]Subnet {netuid} - {stats['symbol']} "
+                f"[cyan]{stats['name']}[/cyan][/{COLOR_PALETTE.G.SYM}]\n"
+                f"Current: [blue]{stats['current_price']:.6f}{stats['symbol']}[/blue]\n"
+            )
+        else:
+            console.print(
+                f"\n[{COLOR_PALETTE.G.SYM}]Subnet {netuid} - {stats['symbol']} "
+                f"[cyan]{stats['name']}[/cyan][/{COLOR_PALETTE.G.SYM}]\n"
+                f"Current: [blue]{stats['symbol']} {stats['current_price']:.6f}[/blue]\n"
+            )
+
+        if netuid != 0:
+            stats_text = (
+                "\nLatest stats:\n"
+                f"Supply: [{COLOR_PALETTE.P.ALPHA_IN}]"
+                f"{stats['supply']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.P.ALPHA_IN}]\n"
+                f"Market Cap: [steel_blue3]{stats['market_cap']:,.2f} {stats['symbol']} / 21M[/steel_blue3]\n"
+                f"Emission: [{COLOR_PALETTE.P.EMISSION}]"
+                f"{stats['emission']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.P.EMISSION}]\n"
+                f"Stake: [{COLOR_PALETTE.S.TAO}]"
+                f"{stats['stake']:,.2f} {stats['symbol']}[/{COLOR_PALETTE.S.TAO}]"
+            )
+        else:
+            stats_text = (
+                "\nLatest stats:\n"
+                f"Supply: [{COLOR_PALETTE.P.ALPHA_IN}]"
+                f"{stats['symbol']} {stats['supply']:,.2f}[/{COLOR_PALETTE.P.ALPHA_IN}]\n"
+                f"Market Cap: [steel_blue3]{stats['symbol']} {stats['market_cap']:,.2f} / 21M[/steel_blue3]\n"
+                f"Emission: [{COLOR_PALETTE.P.EMISSION}]"
+                f"{stats['symbol']} {stats['emission']:,.2f}[/{COLOR_PALETTE.P.EMISSION}]\n"
+                f"Stake: [{COLOR_PALETTE.S.TAO}]"
+                f"{stats['symbol']} {stats['stake']:,.2f}[/{COLOR_PALETTE.S.TAO}]"
+            )
+
+        console.print(stats_text)

bittensor_cli/src/commands/subnets/subnets.py

@@ -36,6 +36,7 @@ from bittensor_cli.src.bittensor.utils import (
     unlock_key,
     blocks_to_duration,
     json_console,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -114,7 +115,7 @@ async def register_subnetwork_extrinsic(
             return False, None
 
     call_params = {
-        "hotkey": wallet.hotkey.ss58_address,
+        "hotkey": get_hotkey_pub_ss58(wallet),
         "mechid": 1,
     }
     call_function = "register_network"
@@ -1654,7 +1655,7 @@ async def register(
             str(netuid),
             f"{Balance.get_unit(netuid)}",
             f"τ {current_recycle.tao:.4f}",
-            f"{wallet.hotkey.ss58_address}",
+            f"{get_hotkey_pub_ss58(wallet)}",
             f"{wallet.coldkeypub.ss58_address}",
         )
         console.print(table)

bittensor_cli/src/commands/sudo.py

@@ -26,6 +26,7 @@ from bittensor_cli.src.bittensor.utils import (
     json_console,
     string_to_u16,
     string_to_u64,
+    get_hotkey_pub_ss58,
 )
 
 if TYPE_CHECKING:
@@ -497,7 +498,7 @@ async def vote_senate_extrinsic(
             call_module="SubtensorModule",
             call_function="vote",
             call_params={
-                "hotkey": wallet.hotkey.ss58_address,
+                "hotkey": get_hotkey_pub_ss58(wallet),
                 "proposal": proposal_hash,
                 "index": proposal_idx,
                 "approve": vote,
@@ -513,9 +514,10 @@ async def vote_senate_extrinsic(
         # Successful vote, final check for data
         else:
             if vote_data := await subtensor.get_vote_data(proposal_hash):
+                hotkey_ss58 = get_hotkey_pub_ss58(wallet)
                 if (
-                    vote_data.ayes.count(wallet.hotkey.ss58_address) > 0
-                    or vote_data.nays.count(wallet.hotkey.ss58_address) > 0
+                    vote_data.ayes.count(hotkey_ss58) > 0
+                    or vote_data.nays.count(hotkey_ss58) > 0
                 ):
                     console.print(":white_heavy_check_mark: [green]Vote cast.[/green]")
                     return True
@@ -859,10 +861,9 @@ async def senate_vote(
         return False
 
     print_verbose(f"Fetching senate status of {wallet.hotkey_str}")
-    if not await _is_senate_member(subtensor, hotkey_ss58=wallet.hotkey.ss58_address):
-        err_console.print(
-            f"Aborting: Hotkey {wallet.hotkey.ss58_address} isn't a senate member."
-        )
+    hotkey_ss58 = get_hotkey_pub_ss58(wallet)
+    if not await _is_senate_member(subtensor, hotkey_ss58=hotkey_ss58):
+        err_console.print(f"Aborting: Hotkey {hotkey_ss58} isn't a senate member.")
         return False
 
     # Unlock the wallet.
@@ -890,7 +891,7 @@ async def senate_vote(
 
 
 async def get_current_take(subtensor: "SubtensorInterface", wallet: Wallet):
-    current_take = await subtensor.current_take(wallet.hotkey.ss58_address)
+    current_take = await subtensor.current_take(get_hotkey_pub_ss58(wallet))
     return current_take
 
 
@@ -912,12 +913,13 @@ async def set_take(
             return False
 
         block_hash = await subtensor.substrate.get_chain_head()
+        hotkey_ss58 = get_hotkey_pub_ss58(wallet)
         netuids_registered = await subtensor.get_netuids_for_hotkey(
-            wallet.hotkey.ss58_address, block_hash=block_hash
+            hotkey_ss58, block_hash=block_hash
         )
         if not len(netuids_registered) > 0:
             err_console.print(
-                f"Hotkey [{COLOR_PALETTE.G.HK}]{wallet.hotkey.ss58_address}[/{COLOR_PALETTE.G.HK}] is not registered to"
+                f"Hotkey [{COLOR_PALETTE.G.HK}]{hotkey_ss58}[/{COLOR_PALETTE.G.HK}] is not registered to"
                 f" any subnet. Please register using [{COLOR_PALETTE.G.SUBHEAD}]`btcli subnets register`"
                 f"[{COLOR_PALETTE.G.SUBHEAD}] and try again."
             )
@@ -926,7 +928,7 @@ async def set_take(
         result: bool = await set_take_extrinsic(
             subtensor=subtensor,
             wallet=wallet,
-            delegate_ss58=wallet.hotkey.ss58_address,
+            delegate_ss58=hotkey_ss58,
             take=take,
         )