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

bittensor_cli/src/commands/stake/children_hotkeys.py

@@ -1,8 +1,9 @@
 import asyncio
+import json
 from typing import Optional
 
 from bittensor_wallet import Wallet
-from rich.prompt import Confirm, Prompt, IntPrompt
+from rich.prompt import Confirm, IntPrompt, FloatPrompt
 from rich.table import Table
 from rich.text import Text
 from async_substrate_interface.errors import SubstrateRequestException
@@ -19,6 +20,7 @@ from bittensor_cli.src.bittensor.utils import (
     is_valid_ss58_address,
     format_error_message,
     unlock_key,
+    json_console,
 )
 
 
@@ -28,24 +30,22 @@ async def get_childkey_completion_block(
     """
     Calculates the block at which the childkey set request will complete
     """
+    bh = await subtensor.substrate.get_chain_head()
     blocks_since_last_step_query = subtensor.query(
-        "SubtensorModule",
-        "BlocksSinceLastStep",
-        params=[netuid],
+        "SubtensorModule", "BlocksSinceLastStep", params=[netuid], block_hash=bh
     )
     tempo_query = subtensor.get_hyperparameter(
-        param_name="Tempo",
-        netuid=netuid,
+        param_name="Tempo", netuid=netuid, block_hash=bh
     )
     block_number, blocks_since_last_step, tempo = await asyncio.gather(
-        subtensor.substrate.get_block_number(),
+        subtensor.substrate.get_block_number(block_hash=bh),
         blocks_since_last_step_query,
         tempo_query,
     )
-    cooldown = block_number + 1
+    cooldown = block_number + 7200
     blocks_left_in_tempo = tempo - blocks_since_last_step
     next_tempo = block_number + blocks_left_in_tempo
-    next_epoch_after_cooldown = (cooldown - next_tempo) % tempo + cooldown
+    next_epoch_after_cooldown = (cooldown - next_tempo) % (tempo + 1) + cooldown
     return block_number, next_epoch_after_cooldown
 
 
@@ -84,7 +84,7 @@ async def set_children_extrinsic(
     if prompt:
         if all_revoked:
             if not Confirm.ask(
-                f"Do you want to revoke all children hotkeys for hotkey {hotkey}?"
+                f"Do you want to revoke all children hotkeys for hotkey {hotkey} on netuid {netuid}?"
             ):
                 return False, "Operation Cancelled"
         else:
@@ -134,17 +134,9 @@ async def set_children_extrinsic(
                 console.print(":white_heavy_check_mark: [green]Included[/green]")
             if wait_for_finalization:
                 console.print(":white_heavy_check_mark: [green]Finalized[/green]")
-            # bittensor.logging.success(
-            #     prefix=operation,
-            #     suffix="<green>Finalized: </green>" + str(success),
-            # )
             return True, f"Successfully {operation.lower()} and Finalized."
         else:
             err_console.print(f":cross_mark: [red]Failed[/red]: {error_message}")
-            # bittensor.logging.warning(
-            #     prefix=operation,
-            #     suffix="<red>Failed: </red>" + str(error_message),
-            # )
             return False, error_message
 
 
@@ -503,6 +495,7 @@ async def set_children(
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
     prompt: bool = True,
+    json_output: bool = False,
 ):
     """Set children hotkeys."""
     # Validate children SS58 addresses
@@ -523,6 +516,7 @@ async def set_children(
             f"Proposed sum of proportions is {total_proposed}."
         )
     children_with_proportions = list(zip(proportions, children))
+    successes = {}
     if netuid is not None:
         success, message = await set_children_extrinsic(
             subtensor=subtensor,
@@ -534,12 +528,20 @@ async def set_children(
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
+        successes[netuid] = {
+            "success": success,
+            "error": message,
+            "completion_block": None,
+            "set_block": None,
+        }
         # Result
         if success:
             if wait_for_inclusion and wait_for_finalization:
                 current_block, completion_block = await get_childkey_completion_block(
                     subtensor, netuid
                 )
+                successes[netuid]["completion_block"] = completion_block
+                successes[netuid]["set_block"] = current_block
                 console.print(
                     f"Your childkey request has been submitted. It will be completed around block {completion_block}. "
                     f"The current block is {current_block}"
@@ -558,7 +560,7 @@ async def set_children(
             if netuid_ == 0:  # dont include root network
                 continue
             console.print(f"Setting children on netuid {netuid_}.")
-            await set_children_extrinsic(
+            success, message = await set_children_extrinsic(
                 subtensor=subtensor,
                 wallet=wallet,
                 netuid=netuid_,
@@ -571,6 +573,12 @@ async def set_children(
             current_block, completion_block = await get_childkey_completion_block(
                 subtensor, netuid_
             )
+            successes[netuid_] = {
+                "success": success,
+                "error": message,
+                "completion_block": completion_block,
+                "set_block": current_block,
+            }
             console.print(
                 f"Your childkey request for netuid {netuid_} has been submitted. It will be completed around "
                 f"block {completion_block}. The current block is {current_block}."
@@ -578,6 +586,8 @@ async def set_children(
         console.print(
             ":white_heavy_check_mark: [green]Sent set children request for all subnets.[/green]"
         )
+    if json_output:
+        json_console.print(json.dumps(successes))
 
 
 async def revoke_children(
@@ -587,11 +597,13 @@ async def revoke_children(
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
     prompt: bool = True,
+    json_output: bool = False,
 ):
     """
     Revokes the children hotkeys associated with a given network identifier (netuid).
     """
-    if netuid:
+    dict_output = {}
+    if netuid is not None:
         success, message = await set_children_extrinsic(
             subtensor=subtensor,
             wallet=wallet,
@@ -602,13 +614,23 @@ async def revoke_children(
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
+        dict_output[netuid] = {
+            "success": success,
+            "error": message,
+            "set_block": None,
+            "completion_block": None,
+        }
 
         # Result
         if success:
-            if wait_for_finalization and wait_for_inclusion:
-                await get_children(wallet, subtensor, netuid)
+            current_block, completion_block = await get_childkey_completion_block(
+                subtensor, netuid
+            )
+            dict_output[netuid]["completion_block"] = completion_block
+            dict_output[netuid]["set_block"] = current_block
             console.print(
-                ":white_heavy_check_mark: [green]Revoked children hotkeys.[/green]"
+                f":white_heavy_check_mark: Your childkey revocation request for netuid {netuid} has been submitted. "
+                f"It will be completed around block {completion_block}. The current block is {current_block}"
             )
         else:
             console.print(
@@ -617,11 +639,11 @@ async def revoke_children(
     else:
         # revoke children from ALL netuids
         netuids = await subtensor.get_all_subnet_netuids()
-        for netuid in netuids:
-            if netuid == 0:  # dont include root network
+        for netuid_ in netuids:
+            if netuid_ == 0:  # dont include root network
                 continue
-            console.print(f"Revoking children from netuid {netuid}.")
-            await set_children_extrinsic(
+            console.print(f"Revoking children from netuid {netuid_}.")
+            success, message = await set_children_extrinsic(
                 subtensor=subtensor,
                 wallet=wallet,
                 netuid=netuid,
@@ -631,9 +653,29 @@ async def revoke_children(
                 wait_for_inclusion=True,
                 wait_for_finalization=False,
             )
-        console.print(
-            ":white_heavy_check_mark: [green]Sent revoke children command. Finalization may take a few minutes.[/green]"
-        )
+            dict_output[netuid_] = {
+                "success": success,
+                "error": message,
+                "set_block": None,
+                "completion_block": None,
+            }
+            if success:
+                current_block, completion_block = await get_childkey_completion_block(
+                    subtensor, netuid_
+                )
+                dict_output[netuid_]["completion_block"] = completion_block
+                dict_output[netuid_]["set_block"] = current_block
+                console.print(
+                    f":white_heavy_check_mark: Your childkey revocation request for netuid {netuid_} has been "
+                    f"submitted. It will be completed around block {completion_block}. The current block "
+                    f"is {current_block}"
+                )
+            else:
+                err_console.print(
+                    f"Childkey revocation failed for netuid {netuid_}: {message}."
+                )
+    if json_output:
+        json_console.print(json.dumps(dict_output))
 
 
 async def childkey_take(
@@ -645,8 +687,13 @@ async def childkey_take(
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
     prompt: bool = True,
-):
-    """Get or Set childkey take."""
+) -> list[tuple[Optional[int], bool]]:
+    """
+    Get or Set childkey take.
+
+    Returns:
+        List of (netuid, success) for specified netuid (or all) and their success in setting take
+    """
 
     def validate_take_value(take_value: float) -> bool:
         if not (0 <= take_value <= 0.18):
@@ -656,20 +703,7 @@ async def childkey_take(
             return False
         return True
 
-    def print_all_takes(takes: list[tuple[int, float]], ss58: str):
-        """Print table with netuids and Takes"""
-        table = Table(
-            title=f"Current Child Takes for [bright_magenta]{ss58}[/bright_magenta]"
-        )
-        table.add_column("Netuid", justify="center", style="cyan")
-        table.add_column("Take (%)", justify="right", style="magenta")
-
-        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, take_netuid):
+    async def display_chk_take(ss58, take_netuid) -> float:
         """Print single key take for hotkey and netuid"""
         chk_take = await get_childkey_take(
             subtensor=subtensor, netuid=take_netuid, hotkey=ss58
@@ -680,6 +714,7 @@ async def childkey_take(
         console.print(
             f"Child take for {ss58} is: {chk_take * 100:.2f}% on netuid {take_netuid}."
         )
+        return chk_take
 
     async def chk_all_subnets(ss58):
         """Aggregate data for childkey take from all subnets"""
@@ -694,10 +729,18 @@ async def childkey_take(
             if curr_take is not None:
                 take_value = u16_to_float(curr_take)
                 takes.append((subnet, take_value * 100))
+        table = Table(
+            title=f"Current Child Takes for [bright_magenta]{ss58}[/bright_magenta]"
+        )
+        table.add_column("Netuid", justify="center", style="cyan")
+        table.add_column("Take (%)", justify="right", style="magenta")
 
-        print_all_takes(takes, ss58)
+        for take_netuid, take_value in takes:
+            table.add_row(str(take_netuid), f"{take_value:.2f}%")
+
+        console.print(table)
 
-    async def set_chk_take_subnet(subnet, chk_take):
+    async def set_chk_take_subnet(subnet: int, chk_take: float) -> bool:
         """Set the childkey take for a single subnet"""
         success, message = await set_childkey_take_extrinsic(
             subtensor=subtensor,
@@ -715,13 +758,17 @@ async def childkey_take(
             console.print(
                 f"The childkey take for {wallet.hotkey.ss58_address} is now set to {take * 100:.2f}%."
             )
+            return True
         else:
             console.print(
                 f":cross_mark:[red] Unable to set childkey take.[/red] {message}"
             )
+            return False
 
     # Print childkey take for other user and return (dont offer to change take rate)
-    if hotkey and hotkey != wallet.hotkey.ss58_address:
+    if not hotkey or hotkey == wallet.hotkey.ss58_address:
+        hotkey = wallet.hotkey.ss58_address
+    if hotkey != wallet.hotkey.ss58_address or not take:
         # display childkey take for other users
         if netuid:
             await display_chk_take(hotkey, netuid)
@@ -729,70 +776,64 @@ async def childkey_take(
                 console.print(
                     f"Hotkey {hotkey} not associated with wallet {wallet.name}."
                 )
-            return
+                return [(netuid, False)]
         else:
-            # show childhotkey take on all subnets
+            # show child hotkey take on all subnets
             await chk_all_subnets(hotkey)
             if take:
                 console.print(
                     f"Hotkey {hotkey} not associated with wallet {wallet.name}."
                 )
-            return
+                return [(netuid, False)]
 
     # Validate child SS58 addresses
     if not take:
-        # print current Take, ask if change
-        if netuid:
-            await display_chk_take(wallet.hotkey.ss58_address, netuid)
-        else:
-            # print take from all netuids
-            await chk_all_subnets(wallet.hotkey.ss58_address)
-
         if not Confirm.ask("Would you like to change the child take?"):
-            return
-        new_take_str = Prompt.ask("Enter the new take value (between 0 and 0.18)")
-        try:
-            new_take_value = float(new_take_str)
-            if not validate_take_value(new_take_value):
-                return
-        except ValueError:
-            err_console.print(
-                ":cross_mark:[red] Invalid input. Please enter a number between 0 and 0.18.[/red]"
+            return [(netuid, False)]
+        new_take_value = -1.0
+        while not validate_take_value(new_take_value):
+            new_take_value = FloatPrompt.ask(
+                "Enter the new take value (between 0 and 0.18)"
             )
-            return
         take = new_take_value
     else:
         if not validate_take_value(take):
-            return
+            return [(netuid, False)]
 
     if netuid:
-        await set_chk_take_subnet(subnet=netuid, chk_take=take)
-        return
+        return [(netuid, await set_chk_take_subnet(subnet=netuid, chk_take=take))]
     else:
         new_take_netuids = IntPrompt.ask(
             "Enter netuid (leave blank for all)", default=None, show_default=True
         )
 
         if new_take_netuids:
-            await set_chk_take_subnet(subnet=new_take_netuids, chk_take=take)
-            return
+            return [
+                (
+                    new_take_netuids,
+                    await set_chk_take_subnet(subnet=new_take_netuids, chk_take=take),
+                )
+            ]
 
         else:
             netuids = await subtensor.get_all_subnet_netuids()
-            for netuid in netuids:
-                if netuid == 0:
+            output_list = []
+            for netuid_ in netuids:
+                if netuid_ == 0:
                     continue
-                console.print(f"Sending to netuid {netuid} take of {take * 100:.2f}%")
-                await set_childkey_take_extrinsic(
+                console.print(f"Sending to netuid {netuid_} take of {take * 100:.2f}%")
+                result = await set_childkey_take_extrinsic(
                     subtensor=subtensor,
                     wallet=wallet,
-                    netuid=netuid,
+                    netuid=netuid_,
                     hotkey=wallet.hotkey.ss58_address,
                     take=take,
                     prompt=prompt,
                     wait_for_inclusion=True,
                     wait_for_finalization=False,
                 )
+                output_list.append((netuid_, result))
             console.print(
                 f":white_heavy_check_mark: [green]Sent childkey take of {take * 100:.2f}% to all subnets.[/green]"
             )
+            return output_list

bittensor_cli/src/commands/stake/list.py

@@ -1,5 +1,6 @@
 import asyncio
-
+import json
+from collections import defaultdict
 from typing import TYPE_CHECKING, Optional
 
 from bittensor_wallet import Wallet
@@ -18,6 +19,7 @@ from bittensor_cli.src.bittensor.utils import (
     print_error,
     millify_tao,
     get_subnet_name,
+    json_console,
 )
 
 if TYPE_CHECKING:
@@ -31,6 +33,7 @@ async def stake_list(
     live: bool = False,
     verbose: bool = False,
     prompt: bool = False,
+    json_output: bool = False,
 ):
     coldkey_address = coldkey_ss58 if coldkey_ss58 else wallet.coldkeypub.ss58_address
 
@@ -152,6 +155,7 @@ async def stake_list(
             reverse=True,
         )
         sorted_substakes = root_stakes + other_stakes
+        substakes_values = []
         for substake_ in sorted_substakes:
             netuid = substake_.netuid
             pool = dynamic_info[netuid]
@@ -195,7 +199,8 @@ async def stake_list(
                     if not verbose
                     else f"{substake_.stake.tao:,.4f}"
                 )
-                subnet_name_cell = f"[{COLOR_PALETTE['GENERAL']['SYMBOL']}]{symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE['GENERAL']['SYMBOL']}] {get_subnet_name(dynamic_info[netuid])}"
+                subnet_name = get_subnet_name(dynamic_info[netuid])
+                subnet_name_cell = f"[{COLOR_PALETTE['GENERAL']['SYMBOL']}]{symbol if netuid != 0 else 'τ'}[/{COLOR_PALETTE['GENERAL']['SYMBOL']}] {subnet_name}"
 
                 rows.append(
                     [
@@ -220,13 +225,28 @@ async def stake_list(
                         str(Balance.from_tao(per_block_tao_emission)),
                     ]
                 )
+                substakes_values.append(
+                    {
+                        "netuid": netuid,
+                        "subnet_name": subnet_name,
+                        "value": tao_value_.tao,
+                        "stake_value": substake_.stake.tao,
+                        "rate": pool.price.tao,
+                        "swap_value": swap_value,
+                        "registered": True if substake_.is_registered else False,
+                        "emission": {
+                            "alpha": per_block_emission,
+                            "tao": per_block_tao_emission,
+                        },
+                    }
+                )
         created_table = define_table(
             name_, rows, total_tao_value_, total_swapped_tao_value_
         )
         for row in rows:
             created_table.add_row(*row)
         console.print(created_table)
-        return total_tao_value_, total_swapped_tao_value_
+        return total_tao_value_, total_swapped_tao_value_, substakes_values
 
     def create_live_table(
         substakes: list,
@@ -409,22 +429,23 @@ async def stake_list(
     # Main execution
     block_hash = await subtensor.substrate.get_chain_head()
     (
-        sub_stakes,
-        registered_delegate_info,
-        dynamic_info,
-    ) = await get_stake_data(block_hash)
-    balance = await subtensor.get_balance(coldkey_address)
+        (
+            sub_stakes,
+            registered_delegate_info,
+            dynamic_info,
+        ),
+        balance,
+    ) = await asyncio.gather(
+        get_stake_data(block_hash),
+        subtensor.get_balance(coldkey_address, block_hash=block_hash),
+    )
 
     # Iterate over substakes and aggregate them by hotkey.
-    hotkeys_to_substakes: dict[str, list[StakeInfo]] = {}
+    hotkeys_to_substakes: dict[str, list[StakeInfo]] = defaultdict(list)
 
     for substake in sub_stakes:
-        hotkey = substake.hotkey_ss58
-        if substake.stake.rao == 0:
-            continue
-        if hotkey not in hotkeys_to_substakes:
-            hotkeys_to_substakes[hotkey] = []
-        hotkeys_to_substakes[hotkey].append(substake)
+        if substake.stake.rao != 0:
+            hotkeys_to_substakes[substake.hotkey_ss58].append(substake)
 
     if not hotkeys_to_substakes:
         print_error(f"No stakes found for coldkey ss58: ({coldkey_address})")
@@ -534,15 +555,24 @@ async def stake_list(
         num_hotkeys = len(hotkeys_to_substakes)
         all_hks_swapped_tao_value = Balance(0)
         all_hks_tao_value = Balance(0)
-        for hotkey in hotkeys_to_substakes.keys():
+        dict_output = {
+            "stake_info": {},
+            "coldkey_address": coldkey_address,
+            "network": subtensor.network,
+            "free_balance": 0.0,
+            "total_tao_value": 0.0,
+            "total_swapped_tao_value": 0.0,
+        }
+        for hotkey, substakes in hotkeys_to_substakes.items():
             counter += 1
-            tao_value, swapped_tao_value = create_table(
-                hotkey, hotkeys_to_substakes[hotkey]
+            tao_value, swapped_tao_value, substake_values_ = create_table(
+                hotkey, substakes
             )
+            dict_output["stake_info"][hotkey] = substake_values_
             all_hks_tao_value += tao_value
             all_hks_swapped_tao_value += swapped_tao_value
 
-            if num_hotkeys > 1 and counter < num_hotkeys and prompt:
+            if num_hotkeys > 1 and counter < num_hotkeys and prompt and not json_output:
                 console.print("\nPress Enter to continue to the next hotkey...")
                 input()
 
@@ -556,7 +586,6 @@ async def stake_list(
             if not verbose
             else all_hks_swapped_tao_value
         )
-
         console.print("\n\n")
         console.print(
             f"Wallet:\n"
@@ -565,6 +594,11 @@ async def stake_list(
             f"  Total TAO Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]\n"
             f"  Total TAO Swapped Value ({Balance.unit}): [{COLOR_PALETTE['GENERAL']['BALANCE']}]{total_swapped_tao_value}[/{COLOR_PALETTE['GENERAL']['BALANCE']}]"
         )
+        dict_output["free_balance"] = balance.tao
+        dict_output["total_tao_value"] = all_hks_tao_value.tao
+        dict_output["total_swapped_tao_value"] = all_hks_swapped_tao_value.tao
+        if json_output:
+            json_console.print(json.dumps(dict_output))
         if not sub_stakes:
             console.print(
                 f"\n[blue]No stakes found for coldkey ss58: ({coldkey_address})"