Merge branch 'staging' into fix/zyzniewski/e2e_python-version

Author: thewhaleking

bittensor_cli/cli.py

@@ -746,23 +746,26 @@ def __init__(self):
         self.SU = self.SUDO
 
     class General(Gettable):
-        HEADER = "#4196D6"  # Light Blue
-        LINKS = "#8CB9E9"  # Sky Blue
-        HINT = "#A2E5B8"  # Mint Green
-        COLDKEY = "#9EF5E4"  # Aqua
-        HOTKEY = "#ECC39D"  # Light Orange/Peach
-        SUBHEADING_MAIN = "#7ECFEC"  # Light Cyan
-        SUBHEADING = "#AFEFFF"  # Pale Blue
-        SUBHEADING_EXTRA_1 = "#96A3C5"  # Grayish Blue
-        SUBHEADING_EXTRA_2 = "#6D7BAF"  # Slate Blue
-        CONFIRMATION_Y_N_Q = "#EE8DF8"  # Light Purple/Pink
-        SYMBOL = "#E7CC51"  # Gold
-        BALANCE = "#4F91C6"  # Medium Blue
-        COST = "#53B5A0"  # Teal
-        SUCCESS = "#53B5A0"  # Teal
-        NETUID = "#CBA880"  # Tan
-        NETUID_EXTRA = "#DDD5A9"  # Light Khaki
-        TEMPO = "#67A3A5"  # Grayish Teal
+        HEADER = "#57878B"  # Mid Blue Green
+        LINKS = "#8CAAAE"  # Pale Blue
+        HINT = "#6C8871"  # Muted Green
+        COLDKEY = "#676B72"  # Dark Grey Blue
+        HOTKEY = "#747065"  # Dark Orange Grey
+        SUBHEADING_MAIN = "#8AA499"  # Muted Blue Green
+        SUBHEADING = "#9BAC9C"  # Pale Green
+        SUBHEADING_EXTRA_1 = "#C596A3"  # Dusty Rose
+        SUBHEADING_EXTRA_2 = "#9BAC9C"  # Pale Green
+        CONFIRMATION_Y_N_Q = "#EFB7AB"  # Pale Pink
+        SYMBOL = "#FE917A"  # Salmon Orange
+        SUBNET_NAME = "#C596A3"  # Dusty Rose
+        VALIDATOR_NAME = "#9BAC9C"  # Mid Lime Green
+        MINER_NAME = "#A17E7E"  # Dusty Red
+        BALANCE = "#757B7B"  # Muted teal Blue
+        COST = "#8EB27A"  # Green
+        SUCCESS = "#3D7F71"  # Dark Teal
+        NETUID = "#BDC1C6"  # GREY_400
+        NETUID_EXTRA = "#D4D0C1"  # Light Yellow Grey
+        TEMPO = "#927A71"  # Dark Tan Brown
         # aliases
         CK = COLDKEY
         HK = HOTKEY
@@ -777,25 +780,25 @@ class Stake(Gettable):
         STAKE_AMOUNT = "#53B5A0"  # Teal
         STAKE_ALPHA = "#53B5A0"  # Teal
         STAKE_SWAP = "#67A3A5"  # Grayish Teal
-        TAO = "#4F91C6"  # Medium Blue
-        SLIPPAGE_TEXT = "#C25E7C"  # Rose
-        SLIPPAGE_PERCENT = "#E7B195"  # Light Coral
-        NOT_REGISTERED = "#EB6A6C"  # Salmon Red
-        EXTRA_1 = "#D781BB"  # Pink
+        TAO = "#8AA499"  # Faded Blue Green
+        SLIPPAGE_TEXT = "#BA938A"  # Brown Salmon
+        SLIPPAGE_PERCENT = "#CD8B7B"  # Muted Salmon
+        NOT_REGISTERED = "#A87D7D"  # Medium Red brown
+        EXTRA_1 = "#A45E44"  # Deep Autumn Orange
         # aliases
         AMOUNT = STAKE_AMOUNT
         ALPHA = STAKE_ALPHA
         SWAP = STAKE_SWAP
 
     class Pools(Gettable):
-        TAO = "#4F91C6"  # Medium Blue
-        ALPHA_IN = "#D09FE9"  # Light Purple
-        ALPHA_OUT = "#AB7CC8"  # Medium Purple
-        RATE = "#F8D384"  # Light Orange
-        TAO_EQUIV = "#8CB9E9"  # Sky Blue
-        EMISSION = "#F8D384"  # Light Orange
-        EXTRA_1 = "#CAA8FB"  # Lavender
-        EXTRA_2 = "#806DAF"  # Dark Purple
+        TAO = "#8AA499"  # Faded Blue Green
+        ALPHA_IN = "#C1913C"  # Mustard
+        ALPHA_OUT = "#B49766"  # Khaki Mustard
+        RATE = "#A46844"  # Deep Orange
+        TAO_EQUIV = "#93BBAF"  # Teal Blue
+        EMISSION = "#B58065"  # Med Orange
+        EXTRA_1 = "#919170"  # Autumn green
+        EXTRA_2 = "#667862"  # Forest green
 
     class Grey(Gettable):
         GREY_100 = "#F8F9FA"  # Almost White
@@ -820,9 +823,9 @@ class Grey(Gettable):
         G_900 = GREY_900
 
     class Sudo(Gettable):
-        HYPERPARAMETER = "#4F91C6"  # Medium Blue
-        VALUE = "#D09FE9"  # Light Purple
-        NORMALIZED = "#AB7CC8"  # Medium Purple
+        HYPERPARAMETER = "#93AFA3"  # Forest
+        VALUE = "#B58065"  # Burnt Orange
+        NORMALIZED = "#A87575"  # Burnt Red
         # aliases
         HYPERPARAM = HYPERPARAMETER
         NORMAL = NORMALIZED

bittensor_cli/src/__init__.py

@@ -749,7 +749,9 @@ def tao_to_alpha_with_slippage(
         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 would a staker receive if they stake their tao using the current pool
+            state.
+
         Args:
             tao: Amount of TAO to stake.
         Returns:
@@ -792,7 +794,9 @@ def alpha_to_tao_with_slippage(
         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 would a staker receive if they unstake their alpha using the current pool
+            state.
+
         Args:
             alpha: Amount of Alpha to stake.
         Returns:

bittensor_cli/src/bittensor/chain_data.py

@@ -524,9 +524,11 @@ async def get_neuron_for_pubkey_and_subnet():
     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 get_neuron_for_pubkey_and_subnet():
                     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/registration.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 _do_set_weights():
         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/root.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 do_transfer() -> tuple[bool, str, str]:
             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 do_transfer() -> tuple[bool, str, str]:
             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 do_transfer() -> tuple[bool, str, str]:
         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