bittensor-cli 9.2.0__py3-none-any.whl → 9.4.0__py3-none-any.whl

bittensor_cli/src/bittensor/chain_data.py

@@ -749,7 +749,9 @@ class DynamicInfo(InfoBase):
         self, tao: Balance
     ) -> tuple[Balance, Balance, float]:
         """
-        Returns an estimate of how much Alpha would a staker receive if they stake their tao using the current pool state.
+        Returns an estimate of how much Alpha a staker would receive if they stake their tao using the current pool
+            state.
+
         Args:
             tao: Amount of TAO to stake.
         Returns:
@@ -792,7 +794,9 @@ class DynamicInfo(InfoBase):
         self, alpha: Balance
     ) -> tuple[Balance, Balance, float]:
         """
-        Returns an estimate of how much TAO would a staker receive if they unstake their alpha using the current pool state.
+        Returns an estimate of how much TAO a staker would receive if they unstake their alpha using the current pool
+            state.
+
         Args:
             alpha: Amount of Alpha to stake.
         Returns:

bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -524,9 +524,11 @@ async def register_extrinsic(
     if prompt:
         if not Confirm.ask(
             f"Continue Registration?\n"
-            f"  hotkey [{COLOR_PALETTE['GENERAL']['HOTKEY']}]({wallet.hotkey_str})[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]:\t[{COLOR_PALETTE['GENERAL']['HOTKEY']}]{wallet.hotkey.ss58_address}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]\n"
-            f"  coldkey [{COLOR_PALETTE['GENERAL']['COLDKEY']}]({wallet.name})[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]:\t[{COLOR_PALETTE['GENERAL']['COLDKEY']}]{wallet.coldkeypub.ss58_address}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]\n"
-            f"  network:\t\t[{COLOR_PALETTE['GENERAL']['LINKS']}]{subtensor.network}[/{COLOR_PALETTE['GENERAL']['LINKS']}]\n"
+            f"  hotkey [{COLOR_PALETTE.G.HK}]({wallet.hotkey_str})[/{COLOR_PALETTE.G.HK}]:"
+            f"\t[{COLOR_PALETTE.G.HK}]{wallet.hotkey.ss58_address}[/{COLOR_PALETTE.G.HK}]\n"
+            f"  coldkey [{COLOR_PALETTE.G.CK}]({wallet.name})[/{COLOR_PALETTE.G.CK}]:"
+            f"\t[{COLOR_PALETTE.G.CK}]{wallet.coldkeypub.ss58_address}[/{COLOR_PALETTE.G.CK}]\n"
+            f"  network:\t\t[{COLOR_PALETTE.G.LINKS}]{subtensor.network}[/{COLOR_PALETTE.G.LINKS}]\n"
         ):
             return False
 
@@ -611,7 +613,6 @@ async def register_extrinsic(
                     if not wait_for_finalization and not wait_for_inclusion:
                         success, err_msg = True, ""
                     else:
-                        await response.process_events()
                         success = await response.is_success
                         if not success:
                             success, err_msg = (
@@ -676,8 +677,9 @@ async def burned_register_extrinsic(
     old_balance: Balance,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
+    era: Optional[int] = None,
     prompt: bool = False,
-) -> bool:
+) -> tuple[bool, str]:
     """Registers the wallet to chain by recycling TAO.
 
     :param subtensor: The SubtensorInterface object to use for the call, initialized
@@ -688,10 +690,11 @@ async def burned_register_extrinsic(
                                `False` if the extrinsic fails to enter the block within the timeout.
     :param wait_for_finalization: If set, waits for the extrinsic to be finalized on the chain before returning `True`,
                                   or returns `False` if the extrinsic fails to be finalized within the timeout.
+    :param era: the period (in blocks) for which the transaction should remain valid.
     :param prompt: If `True`, the call waits for confirmation from the user before proceeding.
 
-    :return: Flag is `True` if extrinsic was finalized or included in the block. If we did not wait for
-             finalization/inclusion, the response is `True`.
+    :return: (success, msg), where success is `True` if extrinsic was finalized or included in the block. If we did not
+        wait for finalization/inclusion, the response is `True`.
     """
 
     if not (unlock_status := unlock_key(wallet, print_out=False)).success:
@@ -704,23 +707,42 @@ async def burned_register_extrinsic(
         my_uid = await subtensor.query(
             "SubtensorModule", "Uids", [netuid, wallet.hotkey.ss58_address]
         )
+        block_hash = await subtensor.substrate.get_chain_head()
 
         print_verbose("Checking if already registered", status)
         neuron = await subtensor.neuron_for_uid(
-            uid=my_uid,
-            netuid=netuid,
-            block_hash=subtensor.substrate.last_block_hash,
+            uid=my_uid, netuid=netuid, block_hash=block_hash
         )
+        if not era:
+            current_block, tempo, blocks_since_last_step = await asyncio.gather(
+                subtensor.substrate.get_block_number(block_hash=block_hash),
+                subtensor.get_hyperparameter(
+                    "Tempo", netuid=netuid, block_hash=block_hash
+                ),
+                subtensor.query(
+                    "SubtensorModule",
+                    "BlocksSinceLastStep",
+                    [netuid],
+                    block_hash=block_hash,
+                ),
+            )
+            validity_period = tempo - blocks_since_last_step
+            era_ = {
+                "period": validity_period,
+                "current": current_block,
+            }
+        else:
+            era_ = {"period": era}
 
     if not neuron.is_null:
         console.print(
             ":white_heavy_check_mark: [dark_sea_green3]Already Registered[/dark_sea_green3]:\n"
-            f"uid: [{COLOR_PALETTE['GENERAL']['NETUID_EXTRA']}]{neuron.uid}[/{COLOR_PALETTE['GENERAL']['NETUID_EXTRA']}]\n"
-            f"netuid: [{COLOR_PALETTE['GENERAL']['NETUID']}]{neuron.netuid}[/{COLOR_PALETTE['GENERAL']['NETUID']}]\n"
-            f"hotkey: [{COLOR_PALETTE['GENERAL']['HOTKEY']}]{neuron.hotkey}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]\n"
-            f"coldkey: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{neuron.coldkey}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]"
+            f"uid: [{COLOR_PALETTE.G.NETUID_EXTRA}]{neuron.uid}[/{COLOR_PALETTE.G.NETUID_EXTRA}]\n"
+            f"netuid: [{COLOR_PALETTE.G.NETUID}]{neuron.netuid}[/{COLOR_PALETTE.G.NETUID}]\n"
+            f"hotkey: [{COLOR_PALETTE.G.HK}]{neuron.hotkey}[/{COLOR_PALETTE.G.HK}]\n"
+            f"coldkey: [{COLOR_PALETTE.G.CK}]{neuron.coldkey}[/{COLOR_PALETTE.G.CK}]"
         )
-        return True
+        return True, "Already registered"
 
     with console.status(
         ":satellite: Recycling TAO for Registration...", spinner="aesthetic"
@@ -734,13 +756,13 @@ async def burned_register_extrinsic(
             },
         )
         success, err_msg = await subtensor.sign_and_send_extrinsic(
-            call, wallet, wait_for_inclusion, wait_for_finalization
+            call, wallet, wait_for_inclusion, wait_for_finalization, era=era_
         )
 
     if not success:
         err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
         await asyncio.sleep(0.5)
-        return False
+        return False, err_msg
     # Successful registration, final check for neuron and pubkey
     else:
         with console.status(":satellite: Checking Balance...", spinner="aesthetic"):
@@ -761,20 +783,21 @@ async def burned_register_extrinsic(
 
         console.print(
             "Balance:\n"
-            f"  [blue]{old_balance}[/blue] :arrow_right: [{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]{new_balance}[/{COLOR_PALETTE['STAKE']['STAKE_AMOUNT']}]"
+            f"  [blue]{old_balance}[/blue] :arrow_right: "
+            f"[{COLOR_PALETTE.S.STAKE_AMOUNT}]{new_balance}[/{COLOR_PALETTE.S.STAKE_AMOUNT}]"
         )
 
         if len(netuids_for_hotkey) > 0:
             console.print(
                 f":white_heavy_check_mark: [green]Registered on netuid {netuid} with UID {my_uid}[/green]"
             )
-            return True
+            return True, f"Registered on {netuid} with UID {my_uid}"
         else:
             # neuron not found, try again
             err_console.print(
                 ":cross_mark: [red]Unknown error. Neuron not found.[/red]"
             )
-            return False
+            return False, "Unknown error. Neuron not found."
 
 
 async def run_faucet_extrinsic(
@@ -894,7 +917,6 @@ async def run_faucet_extrinsic(
             )
 
             # process if registration successful, try again if pow is still valid
-            await response.process_events()
             if not await response.is_success:
                 err_console.print(
                     f":cross_mark: [red]Failed[/red]: "
@@ -1737,7 +1759,8 @@ async def swap_hotkey_extrinsic(
     )
     if not len(netuids_registered) > 0:
         err_console.print(
-            f"Destination hotkey [dark_orange]{new_wallet.hotkey.ss58_address}[/dark_orange] is not registered. Please register and try again"
+            f"Destination hotkey [dark_orange]{new_wallet.hotkey.ss58_address}[/dark_orange] is not registered. "
+            f"Please register and try again"
         )
         return False
 
@@ -1754,7 +1777,8 @@ async def swap_hotkey_extrinsic(
         ):
             return False
     print_verbose(
-        f"Swapping {wallet.name}'s hotkey ({wallet.hotkey.ss58_address}) with {new_wallet.name}s hotkey ({new_wallet.hotkey.ss58_address})"
+        f"Swapping {wallet.name}'s hotkey ({wallet.hotkey.ss58_address}) with "
+        f"{new_wallet.name}s hotkey ({new_wallet.hotkey.ss58_address})"
     )
     with console.status(":satellite: Swapping hotkeys...", spinner="aesthetic"):
         call = await subtensor.substrate.compose_call(

bittensor_cli/src/bittensor/extrinsics/root.py

@@ -291,7 +291,7 @@ async def root_register_extrinsic(
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
     prompt: bool = False,
-) -> bool:
+) -> tuple[bool, str]:
     r"""Registers the wallet to root network.
 
     :param subtensor: The SubtensorInterface object
@@ -302,12 +302,12 @@ async def root_register_extrinsic(
                                   or returns `False` if the extrinsic fails to be finalized within the timeout.
     :param prompt: If `True`, the call waits for confirmation from the user before proceeding.
 
-    :return: `True` if extrinsic was finalized or included in the block. If we did not wait for finalization/inclusion,
-             the response is `True`.
+    :return: (success, msg), with success being `True` if extrinsic was finalized or included in the block. If we did
+        not wait for finalization/inclusion, the response is `True`.
     """
 
-    if not unlock_key(wallet).success:
-        return False
+    if not (unlock := unlock_key(wallet)).success:
+        return False, unlock.message
 
     print_verbose(f"Checking if hotkey ({wallet.hotkey_str}) is registered on root")
     is_registered = await is_hotkey_registered(
@@ -317,7 +317,7 @@ async def root_register_extrinsic(
         console.print(
             ":white_heavy_check_mark: [green]Already registered on root network.[/green]"
         )
-        return True
+        return True, "Already registered on root network"
 
     with console.status(":satellite: Registering to root network...", spinner="earth"):
         call = await subtensor.substrate.compose_call(
@@ -334,8 +334,8 @@ async def root_register_extrinsic(
 
         if not success:
             err_console.print(f":cross_mark: [red]Failed[/red]: {err_msg}")
-            time.sleep(0.5)
-            return False
+            await asyncio.sleep(0.5)
+            return False, err_msg
 
         # Successful registration, final check for neuron and pubkey
         else:
@@ -348,13 +348,13 @@ async def root_register_extrinsic(
                 console.print(
                     f":white_heavy_check_mark: [green]Registered with UID {uid}[/green]"
                 )
-                return True
+                return True, f"Registered with UID {uid}"
             else:
                 # neuron not found, try again
                 err_console.print(
                     ":cross_mark: [red]Unknown error. Neuron not found.[/red]"
                 )
-                return False
+                return False, "Unknown error. Neuron not found."
 
 
 async def set_root_weights_extrinsic(
@@ -410,7 +410,6 @@ async def set_root_weights_extrinsic(
         if not wait_for_finalization and not wait_for_inclusion:
             return True, "Not waiting for finalization or inclusion."
 
-        await response.process_events()
         if await response.is_success:
             return True, "Successfully set weights."
         else:

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -24,6 +24,7 @@ async def transfer_extrinsic(
     wallet: Wallet,
     destination: str,
     amount: Balance,
+    era: int = 3,
     transfer_all: bool = False,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
@@ -36,6 +37,7 @@ async def transfer_extrinsic(
     :param wallet: Bittensor wallet object to make transfer from.
     :param destination: Destination public key address (ss58_address or ed25519) of recipient.
     :param amount: Amount to stake as Bittensor balance.
+    :param era: Length (in blocks) for which the transaction should be valid.
     :param transfer_all: Whether to transfer all funds from this wallet to the destination address.
     :param wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning `True`,
                                or returns `False` if the extrinsic fails to enter the block within the timeout.
@@ -84,7 +86,7 @@ async def transfer_extrinsic(
             call_params={"dest": destination, "value": amount.rao},
         )
         extrinsic = await subtensor.substrate.create_signed_extrinsic(
-            call=call, keypair=wallet.coldkey
+            call=call, keypair=wallet.coldkey, era={"period": era}
         )
         response = await subtensor.substrate.submit_extrinsic(
             extrinsic,
@@ -96,7 +98,6 @@ async def transfer_extrinsic(
             return True, "", ""
 
         # Otherwise continue with finalization.
-        await response.process_events()
         if await response.is_success:
             block_hash_ = response.block_hash
             return True, block_hash_, ""
@@ -155,7 +156,8 @@ async def transfer_extrinsic(
         if not Confirm.ask(
             "Do you want to transfer:[bold white]\n"
             f"  amount: [bright_cyan]{amount}[/bright_cyan]\n"
-            f"  from: [light_goldenrod2]{wallet.name}[/light_goldenrod2] : [bright_magenta]{wallet.coldkey.ss58_address}\n[/bright_magenta]"
+            f"  from: [light_goldenrod2]{wallet.name}[/light_goldenrod2] : "
+            f"[bright_magenta]{wallet.coldkey.ss58_address}\n[/bright_magenta]"
             f"  to: [bright_magenta]{destination}[/bright_magenta]\n  for fee: [bright_cyan]{fee}[/bright_cyan]"
         ):
             return False

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -1048,6 +1048,7 @@ class SubtensorInterface:
         wallet: Wallet,
         wait_for_inclusion: bool = True,
         wait_for_finalization: bool = False,
+        era: Optional[dict[str, int]] = None,
     ) -> tuple[bool, str]:
         """
         Helper method to sign and submit an extrinsic call to chain.
@@ -1056,11 +1057,15 @@ class SubtensorInterface:
         :param wallet: the wallet whose coldkey will be used to sign the extrinsic
         :param wait_for_inclusion: whether to wait until the extrinsic call is included on the chain
         :param wait_for_finalization: whether to wait until the extrinsic call is finalized on the chain
+        :param era: The length (in blocks) for which a transaction should be valid.
 
         :return: (success, error message)
         """
+        call_args = {"call": call, "keypair": wallet.coldkey}
+        if era is not None:
+            call_args["era"] = era
         extrinsic = await self.substrate.create_signed_extrinsic(
-            call=call, keypair=wallet.coldkey
+            **call_args
         )  # sign with coldkey
         try:
             response = await self.substrate.submit_extrinsic(
@@ -1071,7 +1076,6 @@ class SubtensorInterface:
             # We only wait here if we expect finalization.
             if not wait_for_finalization and not wait_for_inclusion:
                 return True, ""
-            await response.process_events()
             if await response.is_success:
                 return True, ""
             else:
@@ -1368,11 +1372,11 @@ class SubtensorInterface:
         This function is useful for analyzing the stake distribution and delegation patterns of multiple
         accounts simultaneously, offering a broader perspective on network participation and investment strategies.
         """
-        BATCH_SIZE = 60
+        batch_size = 60
 
         tasks = []
-        for i in range(0, len(coldkey_ss58_list), BATCH_SIZE):
-            ss58_chunk = coldkey_ss58_list[i : i + BATCH_SIZE]
+        for i in range(0, len(coldkey_ss58_list), batch_size):
+            ss58_chunk = coldkey_ss58_list[i : i + batch_size]
             tasks.append(
                 self.query_runtime_api(
                     runtime_api="StakeInfoRuntimeApi",
@@ -1501,3 +1505,53 @@ class SubtensorInterface:
         )
 
         return Balance.from_rao(result)
+
+    async def get_scheduled_coldkey_swap(
+        self,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> Optional[list[str]]:
+        """
+        Queries the chain to fetch the list of coldkeys that are scheduled for a swap.
+
+        :param block_hash: Block hash at which to perform query.
+        :param reuse_block: Whether to reuse the last-used block hash.
+
+        :return: A list of SS58 addresses of the coldkeys that are scheduled for a coldkey swap.
+        """
+        result = await self.substrate.query_map(
+            module="SubtensorModule",
+            storage_function="ColdkeySwapScheduled",
+            block_hash=block_hash,
+            reuse_block_hash=reuse_block,
+        )
+
+        keys_pending_swap = []
+        async for ss58, _ in result:
+            keys_pending_swap.append(decode_account_id(ss58))
+        return keys_pending_swap
+
+    async def get_coldkey_swap_schedule_duration(
+        self,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> int:
+        """
+        Retrieves the duration (in blocks) required for a coldkey swap to be executed.
+
+        Args:
+            block_hash: The hash of the blockchain block number for the query.
+            reuse_block: Whether to reuse the last-used blockchain block hash.
+
+        Returns:
+            int: The number of blocks required for the coldkey swap schedule duration.
+        """
+        result = await self.query(
+            module="SubtensorModule",
+            storage_function="ColdkeySwapScheduleDuration",
+            params=[],
+            block_hash=block_hash,
+            reuse_block_hash=reuse_block,
+        )
+
+        return result

bittensor_cli/src/bittensor/utils.py

@@ -31,8 +31,10 @@ from bittensor_cli.src import defaults, Constants
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
+    from rich.prompt import PromptBase
 
 console = Console()
+json_console = Console()
 err_console = Console(stderr=True)
 verbose_console = Console(quiet=True)
 
@@ -1006,7 +1008,7 @@ def retry_prompt(
     rejection_text: str,
     default="",
     show_default=False,
-    prompt_type=Prompt.ask,
+    prompt_type: "PromptBase.ask" = Prompt.ask,
 ):
     """
     Allows for asking prompts again if they do not meet a certain criteria (as defined in `rejection`)
@@ -1052,6 +1054,7 @@ def get_effective_network(config, network: Optional[list[str]]) -> str:
     the configuration, and the default.
     """
     if network:
+        network_ = ""
         for item in network:
             if item.startswith("ws"):
                 network_ = item
@@ -1308,7 +1311,8 @@ def print_linux_dependency_message():
         "\tAdd this into the file and save: [green]deb http://archive.ubuntu.com/ubuntu jammy main universe[/green]"
     )
     console.print(
-        "\tUpdate the repository and install the webkit dependency: [green]sudo apt update && sudo apt install libwebkit2gtk-4.0-dev[/green]"
+        "\tUpdate the repository and install the webkit dependency: [green]sudo apt update && sudo apt install "
+        "libwebkit2gtk-4.0-dev[/green]"
     )
     console.print("\nFedora / CentOS / AlmaLinux:")
     console.print("[green]sudo dnf install gtk3-devel webkit2gtk3-devel[/green]\n\n")