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

bittensor_cli/src/commands/stake/add.py

@@ -1,4 +1,6 @@
 import asyncio
+import json
+from collections import defaultdict
 from functools import partial
 
 from typing import TYPE_CHECKING, Optional
@@ -17,6 +19,7 @@ from bittensor_cli.src.bittensor.utils import (
     print_error,
     print_verbose,
     unlock_key,
+    json_console,
 )
 from bittensor_wallet import Wallet
 
@@ -38,6 +41,8 @@ async def stake_add(
     safe_staking: bool,
     rate_tolerance: float,
     allow_partial_stake: bool,
+    json_output: bool,
+    era: int,
 ):
     """
     Args:
@@ -53,6 +58,8 @@ async def stake_add(
         safe_staking: whether to use safe staking
         rate_tolerance: rate tolerance percentage for stake operations
         allow_partial_stake: whether to allow partial stake
+        json_output: whether to output stake info in JSON format
+        era: Blocks for which the transaction should be valid.
 
     Returns:
         bool: True if stake operation is successful, False otherwise
@@ -65,28 +72,31 @@ async def stake_add(
         hotkey_ss58_: str,
         price_limit: Balance,
         status=None,
-    ) -> None:
+    ) -> bool:
         err_out = partial(print_error, status=status)
         failure_prelude = (
             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(
-            wallet.coldkeypub.ss58_address
-        )
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="add_stake_limit",
-            call_params={
-                "hotkey": hotkey_ss58_,
-                "netuid": netuid_,
-                "amount_staked": amount_.rao,
-                "limit_price": price_limit,
-                "allow_partial": allow_partial_stake,
-            },
+        current_balance, next_nonce, call = await asyncio.gather(
+            subtensor.get_balance(wallet.coldkeypub.ss58_address),
+            subtensor.substrate.get_account_next_index(wallet.coldkeypub.ss58_address),
+            subtensor.substrate.compose_call(
+                call_module="SubtensorModule",
+                call_function="add_stake_limit",
+                call_params={
+                    "hotkey": hotkey_ss58_,
+                    "netuid": netuid_,
+                    "amount_staked": 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:
             response = await subtensor.substrate.submit_extrinsic(
@@ -100,73 +110,80 @@ async def stake_add(
                     f"Either increase price tolerance or enable partial staking.",
                     status=status,
                 )
-                return
+                return False
             else:
                 err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
-            return
+            return False
+        if not await response.is_success:
+            err_out(
+                f"\n{failure_prelude} with error: {format_error_message(await response.error_message)}"
+            )
+            return False
         else:
-            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)}"
-                )
-            else:
-                block_hash = await subtensor.substrate.get_chain_head()
-                new_balance, new_stake = await asyncio.gather(
-                    subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash),
-                    subtensor.get_stake(
-                        hotkey_ss58=hotkey_ss58_,
-                        coldkey_ss58=wallet.coldkeypub.ss58_address,
-                        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]"
-                )
-                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_):
-                    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]"
-                    )
+            if json_output:
+                # the rest of this checking is not necessary if using json_output
+                return True
+            block_hash = await subtensor.substrate.get_chain_head()
+            new_balance, new_stake = await asyncio.gather(
+                subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash),
+                subtensor.get_stake(
+                    hotkey_ss58=hotkey_ss58_,
+                    coldkey_ss58=wallet.coldkeypub.ss58_address,
+                    netuid=netuid_,
+                    block_hash=block_hash,
+                ),
+            )
+            console.print(
+                f":white_heavy_check_mark: [dark_sea_green3]Finalized. "
+                f"Stake added to netuid: {netuid_}[/dark_sea_green3]"
+            )
+            console.print(
+                f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: "
+                f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
+            )
 
+            amount_staked = current_balance - new_balance
+            if allow_partial_stake and (amount_staked != amount_):
                 console.print(
-                    f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid_}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
-                    f"Stake:\n"
-                    f"  [blue]{current_stake}[/blue] "
-                    f":arrow_right: "
-                    f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}\n"
+                    "Partial stake transaction. Staked:\n"
+                    f"  [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{amount_staked}"
+                    f"[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}] "
+                    f"instead of "
+                    f"[blue]{amount_}[/blue]"
                 )
 
+            console.print(
+                f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
+                f"{netuid_}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
+                f"Stake:\n"
+                f"  [blue]{current_stake}[/blue] "
+                f":arrow_right: "
+                f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}\n"
+            )
+            return True
+
     async def stake_extrinsic(
         netuid_i, amount_, current, staking_address_ss58, status=None
-    ):
+    ) -> bool:
         err_out = partial(print_error, status=status)
-        current_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
+        current_balance, next_nonce, call = await asyncio.gather(
+            subtensor.get_balance(wallet.coldkeypub.ss58_address),
+            subtensor.substrate.get_account_next_index(wallet.coldkeypub.ss58_address),
+            subtensor.substrate.compose_call(
+                call_module="SubtensorModule",
+                call_function="add_stake",
+                call_params={
+                    "hotkey": staking_address_ss58,
+                    "netuid": netuid_i,
+                    "amount_staked": amount_.rao,
+                },
+            ),
+        )
         failure_prelude = (
             f":cross_mark: [red]Failed[/red] to stake {amount} on Netuid {netuid_i}"
         )
-        next_nonce = await subtensor.substrate.get_account_next_index(
-            wallet.coldkeypub.ss58_address
-        )
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="add_stake",
-            call_params={
-                "hotkey": staking_address_ss58,
-                "netuid": netuid_i,
-                "amount_staked": amount_.rao,
-            },
-        )
         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:
             response = await subtensor.substrate.submit_extrinsic(
@@ -174,35 +191,46 @@ async def stake_add(
             )
         except SubstrateRequestException as e:
             err_out(f"\n{failure_prelude} with error: {format_error_message(e)}")
-            return
+            return False
         else:
-            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 False
             else:
+                if json_output:
+                    # the rest of this is not necessary if using json_output
+                    return True
+                new_block_hash = await subtensor.substrate.get_chain_head()
                 new_balance, new_stake = await asyncio.gather(
-                    subtensor.get_balance(wallet.coldkeypub.ss58_address),
+                    subtensor.get_balance(
+                        wallet.coldkeypub.ss58_address, block_hash=new_block_hash
+                    ),
                     subtensor.get_stake(
                         hotkey_ss58=staking_address_ss58,
                         coldkey_ss58=wallet.coldkeypub.ss58_address,
                         netuid=netuid_i,
+                        block_hash=new_block_hash,
                     ),
                 )
                 console.print(
-                    f":white_heavy_check_mark: [dark_sea_green3]Finalized. Stake added to netuid: {netuid_i}[/dark_sea_green3]"
+                    f":white_heavy_check_mark: "
+                    f"[dark_sea_green3]Finalized. Stake added to netuid: {netuid_i}[/dark_sea_green3]"
                 )
                 console.print(
-                    f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
+                    f"Balance:\n  [blue]{current_balance}[/blue] :arrow_right: "
+                    f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}"
                 )
                 console.print(
-                    f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]{netuid_i}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
+                    f"Subnet: [{COLOR_PALETTE['GENERAL']['SUBHEADING']}]"
+                    f"{netuid_i}[/{COLOR_PALETTE['GENERAL']['SUBHEADING']}] "
                     f"Stake:\n"
                     f"  [blue]{current}[/blue] "
                     f":arrow_right: "
                     f"[{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_stake}\n"
                 )
+                return True
 
     netuids = (
         [int(netuid)]
@@ -282,10 +310,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
@@ -296,6 +338,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
             ]
 
@@ -318,7 +361,9 @@ async def stake_add(
                 base_row.extend(
                     [
                         f"{rate_with_tolerance} {Balance.get_unit(netuid)}/{Balance.get_unit(0)} ",
-                        f"[{'dark_sea_green3' if allow_partial_stake else 'red'}]{allow_partial_stake}[/{'dark_sea_green3' if allow_partial_stake else 'red'}]",  # safe staking
+                        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'}]",
                     ]
                 )
 
@@ -337,7 +382,7 @@ async def stake_add(
         return False
 
     if safe_staking:
-        stake_coroutines = []
+        stake_coroutines = {}
         for i, (ni, am, curr, price_with_tolerance) in enumerate(
             zip(
                 netuids, amounts_to_stake, current_stake_balances, prices_with_tolerance
@@ -346,27 +391,23 @@ async def stake_add(
             for _, staking_address in hotkeys_to_stake_to:
                 # Regular extrinsic for root subnet
                 if ni == 0:
-                    stake_coroutines.append(
-                        stake_extrinsic(
-                            netuid_i=ni,
-                            amount_=am,
-                            current=curr,
-                            staking_address_ss58=staking_address,
-                        )
+                    stake_coroutines[(ni, staking_address)] = stake_extrinsic(
+                        netuid_i=ni,
+                        amount_=am,
+                        current=curr,
+                        staking_address_ss58=staking_address,
                     )
                 else:
-                    stake_coroutines.append(
-                        safe_stake_extrinsic(
-                            netuid_=ni,
-                            amount_=am,
-                            current_stake=curr,
-                            hotkey_ss58_=staking_address,
-                            price_limit=price_with_tolerance,
-                        )
+                    stake_coroutines[(ni, staking_address)] = safe_stake_extrinsic(
+                        netuid_=ni,
+                        amount_=am,
+                        current_stake=curr,
+                        hotkey_ss58_=staking_address,
+                        price_limit=price_with_tolerance,
                     )
     else:
-        stake_coroutines = [
-            stake_extrinsic(
+        stake_coroutines = {
+            (ni, staking_address): stake_extrinsic(
                 netuid_i=ni,
                 amount_=am,
                 current=curr,
@@ -376,12 +417,15 @@ async def stake_add(
                 zip(netuids, amounts_to_stake, current_stake_balances)
             )
             for _, staking_address in hotkeys_to_stake_to
-        ]
-
+        }
+    successes = defaultdict(dict)
     with console.status(f"\n:satellite: Staking on netuid(s): {netuids} ..."):
         # We can gather them all at once but balance reporting will be in race-condition.
-        for coroutine in stake_coroutines:
-            await coroutine
+        for (ni, staking_address), coroutine in stake_coroutines.items():
+            success = await coroutine
+            successes[ni][staking_address] = success
+    if json_output:
+        json_console.print(json.dumps({"staking_success": successes}))
 
 
 # Helper functions
@@ -531,6 +575,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"]
     )
@@ -585,29 +634,41 @@ The columns are as follows:
 
 
 def _calculate_slippage(
-    subnet_info, amount: Balance
+    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