bittensor-cli 9.21.1__tar.gz → 9.21.2__tar.gz

{bittensor_cli-9.21.1 → bittensor_cli-9.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bittensor-cli
-Version: 9.21.1
+Version: 9.21.2
 Summary: Bittensor CLI
 Author: bittensor.com
 Requires-Python: >=3.10
@@ -18,16 +18,13 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Utilities
-Requires-Dist: wheel
-Requires-Dist: async-substrate-interface>=2.0.3,<3.0.0
+Requires-Dist: wheel>0.46.1
+Requires-Dist: async-substrate-interface>=2.0.4,<3.0.0
 Requires-Dist: aiohttp~=3.13
-Requires-Dist: backoff~=2.2.1
 Requires-Dist: bittensor-drand>=1.3.0
 Requires-Dist: GitPython>=3.0.0
 Requires-Dist: netaddr~=1.3.0
-Requires-Dist: numpy>=2.0.1,<3.0.0
 Requires-Dist: Jinja2
-Requires-Dist: pycryptodome>=3.0.0,<4.0.0
 Requires-Dist: PyYAML~=6.0
 Requires-Dist: rich>=13.7,<15.0
 Requires-Dist: cyscale>=0.3.3,<1.0.0
@@ -37,10 +34,8 @@ Requires-Dist: bittensor-wallet==4.0.1
 Requires-Dist: packaging
 Requires-Dist: plotille>=5.0.0
 Requires-Dist: plotly>=6.0.0
-Requires-Dist: torch>=1.13.1,<3.0 ; extra == "cuda"
 Project-URL: Repository, https://github.com/opentensor/btcli
 Project-URL: homepage, https://github.com/opentensor/btcli
-Provides-Extra: cuda
 
 <div align="center">
 

{bittensor_cli-9.21.1 → bittensor_cli-9.21.2}/bittensor_cli/cli.py

@@ -16,7 +16,6 @@ from dataclasses import fields
 from pathlib import Path
 from typing import Coroutine, Optional, Union
 
-import numpy as np
 import rich
 import typer
 from async_substrate_interface.errors import (
@@ -124,8 +123,6 @@ except ImportError:
 logger = logging.getLogger("btcli")
 _epilog = "Made with [bold red]:heart:[/bold red] by The Openτensor Foundaτion"
 
-np.set_printoptions(precision=8, suppress=True, floatmode="fixed")
-
 
 def arg__(arg_name: str) -> str:
     """
@@ -383,6 +380,7 @@ class Options:
         None,
         "--tolerance",
         "--rate-tolerance",
+        "--limit",
         help="Set the rate tolerance percentage for transactions (default: 0.05 for 5%).",
         callback=validate_rate_tolerance,
     )
@@ -1061,9 +1059,6 @@ class CLIManager:
             rich_help_panel=HELP_PANELS["WALLET"]["INFORMATION"],
             hidden=True,
         )(self.wallet_inspect)
-        self.wallet_app.command(
-            "faucet", rich_help_panel=HELP_PANELS["WALLET"]["OPERATIONS"]
-        )(self.wallet_faucet)
         self.wallet_app.command(
             "set-identity", rich_help_panel=HELP_PANELS["WALLET"]["IDENTITY"]
         )(self.wallet_set_id)
@@ -3042,112 +3037,6 @@ class CLIManager:
             )
         )
 
-    def wallet_faucet(
-        self,
-        wallet_name: Optional[str] = Options.wallet_name,
-        wallet_path: Optional[str] = Options.wallet_path,
-        wallet_hotkey: Optional[str] = Options.wallet_hotkey,
-        network: Optional[list[str]] = Options.network,
-        # TODO add the following to config
-        processors: Optional[int] = typer.Option(
-            defaults.pow_register.num_processes,
-            "--processors",
-            help="Number of processors to use for proof of work (POW) registration.",
-        ),
-        update_interval: Optional[int] = typer.Option(
-            defaults.pow_register.update_interval,
-            "--update-interval",
-            "-u",
-            help="The number of nonces to process before checking for next block during registration",
-        ),
-        output_in_place: Optional[bool] = typer.Option(
-            defaults.pow_register.output_in_place,
-            help="Whether to output the registration statistics in-place.",
-        ),
-        verbose: Optional[bool] = typer.Option(  # TODO verbosity handler
-            defaults.pow_register.verbose,
-            "--verbose",
-            "-v",
-            help="Whether to output the registration statistics verbosely.",
-        ),
-        use_cuda: Optional[bool] = typer.Option(
-            defaults.pow_register.cuda.use_cuda,
-            "--use-cuda/--no-use-cuda",
-            "--cuda/--no-cuda",
-            help="Set flag to use CUDA for proof of work (POW) registration.",
-        ),
-        dev_id: Optional[int] = typer.Option(
-            defaults.pow_register.cuda.dev_id,
-            "--dev-id",
-            "-d",
-            help="Set the CUDA device id(s) in the order of speed, where 0 is the fastest.",
-        ),
-        threads_per_block: Optional[int] = typer.Option(
-            defaults.pow_register.cuda.tpb,
-            "--threads-per-block",
-            "-tbp",
-            help="Set the number of threads per block for CUDA.",
-        ),
-        max_successes: Optional[int] = typer.Option(
-            3,
-            "--max-successes",
-            help="Set the maximum number of times to successfully run the faucet for this command.",
-        ),
-        prompt: bool = Options.prompt,
-    ):
-        """
-        Obtain test TAO tokens by performing Proof of Work (PoW).
-
-        This command is useful for users who need test tokens for operations on a local blockchain.
-
-        [blue bold]IMPORTANT[/blue bold]: THIS COMMAND IS DISABLED ON FINNEY AND TESTNET.
-
-        USAGE
-
-        The command uses the proof-of-work (POW) mechanism to validate the user's effort and rewards them with test TAO tokens. It is
-        typically used in local blockchain environments where transactions do not use real TAO tokens.
-
-        EXAMPLE
-
-        [green]$[/green] btcli wallet faucet --faucet.num_processes 4 --faucet.cuda.use_cuda
-
-        [bold]Note[/bold]: This command is meant for used in local environments where users can experiment with the blockchain without using real TAO tokens. Users must have the necessary hardware setup, especially when opting for CUDA-based GPU calculations. It is currently disabled on testnet and mainnet (finney). You can only use this command on a local blockchain.
-        """
-        # TODO should we add json_output?
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            wallet_hotkey,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        logger.debug(
-            "args:\n"
-            f"network {network}\n"
-            f"threads_per_block {threads_per_block}\n"
-            f"update_interval {update_interval}\n"
-            f"processors {processors}\n"
-            f"use_cuda {use_cuda}\n"
-            f"dev_id {dev_id}\n"
-            f"output_in_place {output_in_place}\n"
-            f"max_successes {max_successes}\n"
-        )
-        return self._run_command(
-            wallets.faucet(
-                wallet,
-                self.initialize_chain(network),
-                threads_per_block,
-                update_interval,
-                processors,
-                use_cuda,
-                dev_id,
-                output_in_place,
-                verbose,
-                max_successes,
-                prompt,
-            )
-        )
-
     def wallet_regen_coldkey(
         self,
         wallet_name: Optional[str] = Options.wallet_name,

{bittensor_cli-9.21.1 → bittensor_cli-9.21.2}/bittensor_cli/src/__init__.py

@@ -81,17 +81,6 @@ class Defaults:
         chain_endpoint = None
         _mock = False
 
-    class pow_register:
-        num_processes = None
-        update_interval = 50_000
-        output_in_place = True
-        verbose = False
-
-        class cuda:
-            dev_id = 0
-            use_cuda = False
-            tpb = 256
-
     class wallet:
         name = "default"
         hotkey = "default"

bittensor_cli-9.21.2/bittensor_cli/src/bittensor/extrinsics/registration.py

@@ -0,0 +1,286 @@
+import asyncio
+import time
+import typing
+from typing import Optional
+
+from async_substrate_interface import AsyncExtrinsicReceipt
+from bittensor_wallet import Wallet
+
+from bittensor_cli.src import COLOR_PALETTE
+from bittensor_cli.src.bittensor.balances import Balance
+from bittensor_cli.src.bittensor.utils import (
+    confirm_action,
+    console,
+    print_error,
+    print_success,
+    print_verbose,
+    unlock_key,
+    get_hotkey_pub_ss58,
+    print_extrinsic_id,
+)
+
+if typing.TYPE_CHECKING:
+    from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
+
+
+async def is_hotkey_registered(
+    subtensor: "SubtensorInterface", netuid: int, hotkey_ss58: str
+) -> bool:
+    """Checks to see if the hotkey is registered on a given netuid"""
+    _result = await subtensor.query(
+        module="SubtensorModule",
+        storage_function="Uids",
+        params=[netuid, hotkey_ss58],
+    )
+    if _result is not None:
+        return True
+    else:
+        return False
+
+
+async def burned_register_extrinsic(
+    subtensor: "SubtensorInterface",
+    wallet: Wallet,
+    netuid: int,
+    old_balance: Balance,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
+    era: Optional[int] = None,
+    proxy: Optional[str] = None,
+    limit: Optional[float] = None,
+) -> tuple[bool, str, Optional[str]]:
+    """Registers the wallet to chain by recycling TAO.
+
+    :param subtensor: The SubtensorInterface object to use for the call, initialized
+    :param wallet: Bittensor wallet object.
+    :param netuid: The `netuid` of the subnet to register on.
+    :param old_balance: The wallet balance prior to the registration burn.
+    :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.
+    :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 proxy: the proxy address to use for the call.
+
+    :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:
+        return False, unlock_status.message, None
+
+    with console.status(
+        f":satellite: Checking Account on [bold]subnet:{netuid}[/bold]...",
+        spinner="aesthetic",
+    ) as status:
+        block_hash = await subtensor.substrate.get_chain_head()
+        my_uid = await subtensor.query(
+            module="SubtensorModule",
+            storage_function="Uids",
+            params=[netuid, get_hotkey_pub_ss58(wallet)],
+            block_hash=block_hash,
+        )
+        print_verbose("Checking if already registered", status)
+        neuron = await subtensor.neuron_for_uid(
+            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:
+        print_success("[dark_sea_green3]Already Registered[/dark_sea_green3]:")
+        console.print(
+            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, "Already registered", None
+
+    with console.status(
+        ":satellite: Recycling TAO for Registration...", spinner="aesthetic"
+    ):
+        call_data = {
+            "call_module": "SubtensorModule",
+            "call_params": {"netuid": netuid, "hotkey": get_hotkey_pub_ss58(wallet)},
+            "block_hash": block_hash,
+        }
+        if limit is not None:
+            call_data["call_params"]["limit_price"] = Balance.from_tao(limit).rao
+            call_data["call_function"] = "register_limit"
+        else:
+            call_data["call_function"] = "burned_register"
+        call = await subtensor.substrate.compose_call(
+            **call_data,
+        )
+        success, err_msg, ext_receipt = await subtensor.sign_and_send_extrinsic(
+            call,
+            wallet,
+            wait_for_inclusion,
+            wait_for_finalization,
+            era=era_,
+            proxy=proxy,
+        )
+
+    if not success:
+        print_error(f"Failed: {err_msg}")
+        await asyncio.sleep(0.5)
+        return False, err_msg, None
+    # Successful registration, final check for neuron and pubkey
+    else:
+        ext_id = await ext_receipt.get_extrinsic_identifier()
+        await print_extrinsic_id(ext_receipt)
+        with console.status(":satellite: Checking Balance...", spinner="aesthetic"):
+            block_hash = await subtensor.substrate.get_chain_head()
+            new_balance, netuids_for_hotkey, my_uid = await asyncio.gather(
+                subtensor.get_balance(
+                    wallet.coldkeypub.ss58_address,
+                    block_hash=block_hash,
+                ),
+                subtensor.get_netuids_for_hotkey(
+                    get_hotkey_pub_ss58(wallet), block_hash=block_hash
+                ),
+                subtensor.query(
+                    "SubtensorModule", "Uids", [netuid, get_hotkey_pub_ss58(wallet)]
+                ),
+            )
+
+        console.print(
+            "Balance:\n"
+            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:
+            print_success(f"Registered on netuid {netuid} with UID {my_uid}")
+            return True, f"Registered on {netuid} with UID {my_uid}", ext_id
+        else:
+            # neuron not found, try again
+            print_error("Unknown error. Neuron not found.")
+            return False, "Unknown error. Neuron not found.", ext_id
+
+
+async def swap_hotkey_extrinsic(
+    subtensor: "SubtensorInterface",
+    wallet: Wallet,
+    new_wallet: Wallet,
+    netuid: Optional[int] = None,
+    proxy: Optional[str] = None,
+    prompt: bool = False,
+    decline: bool = False,
+    quiet: bool = False,
+) -> tuple[bool, Optional[AsyncExtrinsicReceipt]]:
+    """
+    Performs an extrinsic update for swapping two hotkeys on the chain
+
+    :return: Success
+    """
+    block_hash = await subtensor.substrate.get_chain_head()
+    hk_ss58 = get_hotkey_pub_ss58(wallet)
+    new_hk_ss58 = get_hotkey_pub_ss58(new_wallet)
+
+    netuids_registered = await subtensor.get_netuids_for_hotkey(
+        hk_ss58, block_hash=block_hash
+    )
+    netuids_registered_new_hotkey = await subtensor.get_netuids_for_hotkey(
+        new_hk_ss58, block_hash=block_hash
+    )
+
+    if netuid is not None and netuid not in netuids_registered:
+        print_error(
+            f"Failed: Original hotkey {hk_ss58} is not registered on subnet {netuid}"
+        )
+        return False, None
+
+    elif not len(netuids_registered) > 0:
+        print_error(
+            f"Original hotkey [dark_orange]{hk_ss58}[/dark_orange] is not registered on any subnet. "
+            f"Please register and try again"
+        )
+        return False, None
+
+    if netuid is not None:
+        if netuid in netuids_registered_new_hotkey:
+            print_error(
+                f"Failed: New hotkey {new_hk_ss58} "
+                f"is already registered on subnet {netuid}"
+            )
+            return False, None
+    else:
+        if len(netuids_registered_new_hotkey) > 0:
+            print_error(
+                f"Failed: New hotkey {new_hk_ss58} "
+                f"is already registered on subnet(s) {netuids_registered_new_hotkey}"
+            )
+            return False, None
+
+    if not unlock_key(wallet).success:
+        return False, None
+
+    if prompt:
+        # Prompt user for confirmation.
+        if netuid is not None:
+            confirm_message = (
+                f"Do you want to swap [dark_orange]{wallet.name}[/dark_orange] hotkey \n\t"
+                f"[dark_orange]{hk_ss58} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_hk_ss58} ({new_wallet.hotkey_str})[/dark_orange] on subnet {netuid}\n"
+                "This operation will cost [bold cyan]1 TAO (recycled)[/bold cyan]"
+            )
+        else:
+            confirm_message = (
+                f"Do you want to swap [dark_orange]{wallet.name}[/dark_orange] hotkey \n\t"
+                f"[dark_orange]{hk_ss58} ({wallet.hotkey_str})[/dark_orange] with hotkey \n\t"
+                f"[dark_orange]{new_hk_ss58} ({new_wallet.hotkey_str})[/dark_orange] on all subnets\n"
+                "This operation will cost [bold cyan]1 TAO (recycled)[/bold cyan]"
+            )
+
+        if not confirm_action(confirm_message, decline=decline, quiet=quiet):
+            return False, None
+    print_verbose(
+        f"Swapping {wallet.name}'s hotkey ({hk_ss58} - {wallet.hotkey_str}) with "
+        f"{new_wallet.name}'s hotkey ({new_hk_ss58} - {new_wallet.hotkey_str})"
+    )
+    with console.status(":satellite: Swapping hotkeys...", spinner="aesthetic"):
+        call_params = {
+            "hotkey": hk_ss58,
+            "new_hotkey": new_hk_ss58,
+            "netuid": netuid,
+        }
+
+        call = await subtensor.substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="swap_hotkey",
+            call_params=call_params,
+        )
+        success, err_msg, ext_receipt = await subtensor.sign_and_send_extrinsic(
+            call=call, wallet=wallet, proxy=proxy
+        )
+
+        if success:
+            console.print(
+                f"Hotkey {hk_ss58} ({wallet.hotkey_str}) swapped for new hotkey: "
+                f"{new_hk_ss58} ({new_wallet.hotkey_str})"
+            )
+            return True, ext_receipt
+        else:
+            print_error(f"Failed: {err_msg}")
+            time.sleep(0.5)
+            return False, ext_receipt