Pre-merge merge (async extrinsics)

Author: thewhaleking

bittensor/core/async_subtensor.py

@@ -27,15 +27,15 @@
     PrometheusInfo,
     ProposalVoteData,
 )
-from bittensor.core.extrinsics.asyncio.registration import register_extrinsic
-from bittensor.core.extrinsics.asyncio.transfer import transfer_extrinsic
-from bittensor.core.extrinsics.asyncio.weights import (
+from bittensor.core.extrinsics.asyncex.registration import register_extrinsic
+from bittensor.core.extrinsics.asyncex.transfer import transfer_extrinsic
+from bittensor.core.extrinsics.asyncex.weights import (
     commit_weights_extrinsic,
     set_weights_extrinsic,
 )
-from bittensor.core.extrinsics.asyncio.serving import serve_axon_extrinsic
-from bittensor.core.extrinsics.asyncio.unstaking import unstake_extrinsic
-from bittensor.core.extrinsics.asyncio.commit_reveal import commit_reveal_v3_extrinsic
+from bittensor.core.extrinsics.asyncex.serving import serve_axon_extrinsic
+from bittensor.core.extrinsics.asyncex.unstaking import unstake_extrinsic
+from bittensor.core.extrinsics.asyncex.commit_reveal import commit_reveal_v3_extrinsic
 from bittensor.core.settings import (
     TYPE_REGISTRY,
     DEFAULTS,

…nsor/core/extrinsics/asyncio/__init__.py …nsor/core/extrinsics/asyncex/__init__.pybittensor/core/extrinsics/asyncio/__init__.py renamed to bittensor/core/extrinsics/asyncex/__init__.py bittensor/core/extrinsics/asyncio/__init__.py renamed to bittensor/core/extrinsics/asyncex/__init__.py

@@ -1,10 +1,11 @@
+"""This module provides async functionality for commit reveal in the Bittensor network."""
+
 from typing import Optional, Union, TYPE_CHECKING
 
 import numpy as np
 from bittensor_commit_reveal import get_encrypted_commit
 from numpy.typing import NDArray
 
-from bittensor.core.extrinsics.utils import async_submit_extrinsic
 from bittensor.core.settings import version_as_int
 from bittensor.utils import format_error_message
 from bittensor.utils.btlogging import logging
@@ -26,10 +27,10 @@ async def _do_commit_reveal_v3(
     wait_for_finalization: bool = False,
 ) -> tuple[bool, Optional[str]]:
     """
-    Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or
-        finalization.
+    Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or finalization.
 
     Arguments:
+        subtensor: An instance of the Subtensor class.
         wallet: Wallet An instance of the Wallet class containing the user's keypair.
         netuid: int The network unique identifier.
         commit  bytes The commit data in bytes format.
@@ -38,8 +39,7 @@ async def _do_commit_reveal_v3(
         wait_for_finalization: bool, optional Flag indicating whether to wait for the extrinsic to be finalized.
 
     Returns:
-        A tuple where the first element is a boolean indicating success or failure, and the second element is an
-            optional string containing error message if any.
+        A tuple where the first element is a boolean indicating success or failure, and the second element is an optional string containing error message if any.
     """
     logging.info(
         f"Committing weights hash [blue]{commit.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
@@ -55,13 +55,13 @@ async def _do_commit_reveal_v3(
             "reveal_round": reveal_round,
         },
     )
+
     extrinsic = await subtensor.substrate.create_signed_extrinsic(
         call=call,
         keypair=wallet.hotkey,
     )
 
-    response = await async_submit_extrinsic(
-        subtensor=subtensor,
+    response = await subtensor.substrate.submit_extrinsic(
         extrinsic=extrinsic,
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
@@ -70,10 +70,10 @@ async def _do_commit_reveal_v3(
     if not wait_for_finalization and not wait_for_inclusion:
         return True, "Not waiting for finalization or inclusion."
 
-    if response.is_success:
+    if await response.is_success:
         return True, None
-    else:
-        return False, format_error_message(response.error_message)
+
+    return False, format_error_message(await response.error_message)
 
 
 async def commit_reveal_v3_extrinsic(
@@ -143,15 +143,15 @@ async def commit_reveal_v3_extrinsic(
             wait_for_finalization=wait_for_finalization,
         )
 
-        if success is True:
-            logging.success(
-                f"[green]Finalized![/green] Weights commited with reveal round [blue]{reveal_round}[/blue]."
-            )
-            return True, f"reveal_round:{reveal_round}"
-        else:
+        if success is not True:
             logging.error(message)
             return False, message
 
+        logging.success(
+            f"[green]Finalized![/green] Weights commited with reveal round [blue]{reveal_round}[/blue]."
+        )
+        return True, f"reveal_round:{reveal_round}"
+
     except Exception as e:
         logging.error(f":cross_mark: [red]Failed. Error:[/red] {e}")
         return False, str(e)

…core/extrinsics/asyncio/commit_reveal.py …core/extrinsics/asyncex/commit_reveal.pybittensor/core/extrinsics/asyncio/commit_reveal.py renamed to bittensor/core/extrinsics/asyncex/commit_reveal.py bittensor/core/extrinsics/asyncio/commit_reveal.py renamed to bittensor/core/extrinsics/asyncex/commit_reveal.py

@@ -1,23 +1,23 @@
 """
-This module provides functionalities for registering a wallet with the subtensor network using Proof-of-Work (PoW).
+This module provides asynchronous functionalities for registering a wallet with the subtensor network using
+Proof-of-Work (PoW).
 
 Extrinsics:
 - register_extrinsic: Registers the wallet to the subnet.
-- run_faucet_extrinsic: Runs a continual POW to get a faucet of TAO on the test net.
+- burned_register_extrinsic: Registers the wallet to chain by recycling TAO.
 """
 
 import asyncio
 from typing import Optional, Union, TYPE_CHECKING
 
-from bittensor_wallet import Wallet
-
 from bittensor.utils import format_error_message
+from bittensor.utils import unlock_key
 from bittensor.utils.btlogging import logging
 from bittensor.utils.registration import log_no_torch_error, create_pow_async
 
-# For annotation and lazy import purposes
 if TYPE_CHECKING:
     import torch
+    from bittensor_wallet import Wallet
     from bittensor.core.async_subtensor import AsyncSubtensor
     from bittensor.utils.registration.pow import POWSolution
 else:
@@ -34,6 +34,147 @@ class MaxAttemptsException(Exception):
     """Raised when the POW Solver has reached the max number of attempts."""
 
 
+async def _do_burned_register(
+    subtensor: "AsyncSubtensor",
+    netuid: int,
+    wallet: "Wallet",
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = True,
+) -> tuple[bool, Optional[str]]:
+    """
+    Performs a burned register extrinsic call to the Subtensor chain.
+
+    This method sends a registration transaction to the Subtensor blockchain using the burned register mechanism.
+
+    Args:
+        subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+        netuid (int): The network unique identifier to register on.
+        wallet (bittensor_wallet.Wallet): The wallet to be registered.
+        wait_for_inclusion (bool): Whether to wait for the transaction to be included in a block. Default is False.
+        wait_for_finalization (bool): Whether to wait for the transaction to be finalized. Default is True.
+
+    Returns:
+        Tuple[bool, Optional[str]]: A tuple containing a boolean indicating success or failure, and an optional error message.
+    """
+
+    # create extrinsic call
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="burned_register",
+        call_params={
+            "netuid": netuid,
+            "hotkey": wallet.hotkey.ss58_address,
+        },
+    )
+    extrinsic = await subtensor.substrate.create_signed_extrinsic(
+        call=call, keypair=wallet.coldkey
+    )
+    response = await subtensor.substrate.submit_extrinsic(
+        extrinsic=extrinsic,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    # We only wait here if we expect finalization.
+    if not wait_for_finalization and not wait_for_inclusion:
+        return True, None
+
+    # process if registration successful, try again if pow is still valid
+    if not await response.is_success:
+        return False, format_error_message(await response.error_message)
+    # Successful registration
+
+    return True, None
+
+
+async def burned_register_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    netuid: int,
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = True,
+) -> bool:
+    """Registers the wallet to chain by recycling TAO.
+
+    Args:
+        subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+        wallet (bittensor.wallet): Bittensor wallet object.
+        netuid (int): The ``netuid`` of the subnet to register on.
+        wait_for_inclusion (bool): 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.
+        wait_for_finalization (bool): 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.
+
+    Returns:
+        success (bool): Flag is ``true`` if extrinsic was finalized or uncluded in the block. If we did not wait for finalization / inclusion, the response is ``true``.
+    """
+    if not await subtensor.subnet_exists(netuid):
+        logging.error(
+            f":cross_mark: [red]Failed error:[/red] subnet [blue]{netuid}[/blue] does not exist."
+        )
+        return False
+
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False
+
+    logging.info(
+        f":satellite: [magenta]Checking Account on subnet[/magenta] [blue]{netuid}[/blue][magenta] ...[/magenta]"
+    )
+    neuron = await subtensor.get_neuron_for_pubkey_and_subnet(
+        wallet.hotkey.ss58_address, netuid=netuid
+    )
+
+    old_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
+
+    if not neuron.is_null:
+        logging.info(":white_heavy_check_mark: [green]Already Registered[/green]")
+        logging.info(f"\t\tuid: [blue]{neuron.uid}[/blue]")
+        logging.info(f"\t\tnetuid: [blue]{neuron.netuid}[/blue]")
+        logging.info(f"\t\thotkey: [blue]{neuron.hotkey}[/blue]")
+        logging.info(f"\t\tcoldkey: [blue]{neuron.coldkey}[/blue]")
+        return True
+
+    logging.info(":satellite: [magenta]Recycling TAO for Registration...[/magenta]")
+
+    recycle_amount = await subtensor.recycle(netuid=netuid)
+    logging.info(f"Recycling {recycle_amount} to register on subnet:{netuid}")
+
+    success, err_msg = await _do_burned_register(
+        subtensor=subtensor,
+        netuid=netuid,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    if not success:
+        logging.error(f":cross_mark: [red]Failed error:[/red] {err_msg}")
+        await asyncio.sleep(0.5)
+        return False
+    # Successful registration, final check for neuron and pubkey
+    else:
+        logging.info(":satellite: [magenta]Checking Balance...[/magenta]")
+        block_hash = await subtensor.substrate.get_chain_head()
+        new_balance = await subtensor.get_balance(
+            wallet.coldkeypub.ss58_address, block_hash=block_hash
+        )
+
+        logging.info(
+            f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
+        )
+        is_registered = await subtensor.is_hotkey_registered(
+            netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
+        )
+        if is_registered:
+            logging.info(":white_heavy_check_mark: [green]Registered[/green]")
+            return True
+        else:
+            # neuron not found, try again
+            logging.error(":cross_mark: [red]Unknown error. Neuron not found.[/red]")
+            return False
+
+
 async def _do_pow_register(
     subtensor: "AsyncSubtensor",
     netuid: int,
@@ -142,9 +283,11 @@ async def register_extrinsic(
     )
 
     if not neuron.is_null:
-        logging.debug(
-            f"Wallet [green]{wallet}[/green] is already registered on subnet [blue]{neuron.netuid}[/blue] with uid[blue]{neuron.uid}[/blue]."
-        )
+        logging.info(":white_heavy_check_mark: [green]Already Registered[/green]")
+        logging.info(f"\t\tuid: [blue]{neuron.uid}[/blue]")
+        logging.info(f"\t\tnetuid: [blue]{neuron.netuid}[/blue]")
+        logging.info(f"\t\thotkey: [blue]{neuron.hotkey}[/blue]")
+        logging.info(f"\t\tcoldkey: [blue]{neuron.coldkey}[/blue]")
         return True
 
     logging.debug(

…/core/extrinsics/asyncio/registration.py …/core/extrinsics/asyncex/registration.pybittensor/core/extrinsics/asyncio/registration.py renamed to bittensor/core/extrinsics/asyncex/registration.py bittensor/core/extrinsics/asyncio/registration.py renamed to bittensor/core/extrinsics/asyncex/registration.py

@@ -119,9 +119,11 @@ async def _do_set_root_weights(
     wallet: "Wallet",
     netuids: Union[NDArray[np.int64], list[int]],
     weights: Union[NDArray[np.float32], list[float]],
+    netuid: int = 0,
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    period: int = 5,
 ) -> tuple[bool, str]:
     """
     Sets the root weights on the Subnet for the given wallet hotkey account.
@@ -134,9 +136,11 @@ async def _do_set_root_weights(
         wallet (bittensor_wallet.Wallet): The wallet containing the hotkey and coldkey for the transaction.
         netuids (Union[NDArray[np.int64], list[int]]): List of UIDs to set weights for.
         weights (Union[NDArray[np.float32], list[float]]): Corresponding weights to set for each UID.
+        netuid (int): The netuid of the subnet to set weights for. Defaults to 0.
         version_key (int, optional): The version key of the validator. Defaults to 0.
         wait_for_inclusion (bool, optional): If True, waits for the extrinsic to be included in a block. Defaults to False.
         wait_for_finalization (bool, optional): If True, waits for the extrinsic to be finalized on the chain. Defaults to False.
+        period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
 
     Returns:
         tuple: Returns a tuple containing a boolean indicating success and a message describing the result of the operation.
@@ -147,7 +151,7 @@ async def _do_set_root_weights(
         call_params={
             "dests": netuids,
             "weights": weights,
-            "netuid": 0,
+            "netuid": netuid,
             "version_key": version_key,
             "hotkey": wallet.hotkey.ss58_address,
         },
@@ -156,10 +160,10 @@ async def _do_set_root_weights(
     extrinsic = await subtensor.substrate.create_signed_extrinsic(
         call=call,
         keypair=wallet.coldkey,
-        era={"period": 5},
+        era={"period": period},
     )
     response = await subtensor.substrate.submit_extrinsic(
-        extrinsic,
+        extrinsic=extrinsic,
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
     )