diff --git a/.circleci/config.yml b/.circleci/config.yml
index 80bdc8c318..eb524eda71 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -287,6 +287,10 @@ workflows:
- check_compatibility:
python_version: "3.11"
name: check-compatibility-3.11
+ - check_compatibility:
+ python_version: "3.12"
+ name: check-compatibility-3.12
+
pr-requirements:
jobs:
@@ -298,7 +302,7 @@ workflows:
- build-and-test:
matrix:
parameters:
- python-version: ["3.9.13", "3.10.6", "3.11.4"]
+ python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7" ]
requires:
- check-if-pr-is-draft
- unit-tests-all-python-versions:
@@ -307,7 +311,7 @@ workflows:
- lint-and-type-check:
matrix:
parameters:
- python-version: ["3.9.13", "3.10.6", "3.11.4"]
+ python-version: [ "3.9.13", "3.10.6", "3.11.4", "3.12.7" ]
requires:
- check-if-pr-is-draft
#- coveralls:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c2b308cf9..4f5da1522e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,55 @@
# Changelog
+## 8.4.0 /2024-11-27
+
+## What's Changed
+
+* Async unittests for `bittensor/core/extrinsics/async_weights.py` by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2425
+* Async unittests for `bittensor/core/extrinsics/async_transfer.py` by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2426
+* Async `unittests for bittensor/core/extrinsics/async_root.py` by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2427
+* Removes Conda Info by @thewhaleking in https://github.com/opentensor/bittensor/pull/2437
+* Fix typos by @omahs in https://github.com/opentensor/bittensor/pull/2440
+* [SDK] Registration related content refactoring by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2439
+* Async unittests for `bittensor/core/extrinsics/async_registration.py` by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2445
+* BittensorConsole class by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2446
+* Improve reconnection logic by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2442
+* E2E tests - Increasing Subtensor coverage (Pt 1) by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2443
+* Add python3.12 support by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2450
+* add neuron certificate discovery by @andreea-popescu-reef in https://github.com/opentensor/bittensor/pull/2267
+* Use websockets for Subtensor by @thewhaleking in https://github.com/opentensor/bittensor/pull/2455
+* Part 2: E2E tests - Increasing Subtensor coverage by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2457
+* Tests for subtensor methods related with `stake` and `unstake` extrinsics by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2458
+* Apply BittensorConsole + logging refactoring by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2452
+* Add staking and unstaking extrinsics by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2456
+* Don't strip ANSI from stdout (fixes #2365) by @vaqxai in https://github.com/opentensor/bittensor/pull/2366
+* Support fastblocks when setting root set weights in e2e tests by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2464
+* Extrinsic Submission Timeout by @thewhaleking in https://github.com/opentensor/bittensor/pull/2448
+* Resync async substrate by @thewhaleking in https://github.com/opentensor/bittensor/pull/2463
+* Fixes logging when setting weights by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2465
+* Integration tests by @thewhaleking in https://github.com/opentensor/bittensor/pull/2433
+* Fixes logic for checking block_since_last_update by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2473
+* Update unit tests websocket by @thewhaleking in https://github.com/opentensor/bittensor/pull/2468
+* Improve MockSubtensor by @thewhaleking in https://github.com/opentensor/bittensor/pull/2469
+* Fixes logging when passing multiple objects by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2477
+* Add script for solving ssl issue by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2474
+* Improve async docstrings by @thewhaleking in https://github.com/opentensor/bittensor/pull/2478
+* fix: increase stacklevel in LoggingMachine log calls by @zyzniewski-reef in https://github.com/opentensor/bittensor/pull/2476
+* remove uses of return scale obj by @thewhaleking in https://github.com/opentensor/bittensor/pull/2479
+* Backmerge master to staging for 8.4.0 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2482
+* Expand `reuse_block` by @thewhaleking in https://github.com/opentensor/bittensor/pull/2481
+* Add NeuronInfo list from vec u8 by @camfairchild in https://github.com/opentensor/bittensor/pull/2480
+* Update `ensure_connected` for websockets by @thewhaleking in https://github.com/opentensor/bittensor/pull/2486
+* MockSubtensor work offline by @thewhaleking in https://github.com/opentensor/bittensor/pull/2487
+* Add `wait_for_block` method by @thewhaleking in https://github.com/opentensor/bittensor/pull/2489
+* Updates btwallet to 2.1.2 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2490
+* Bumps bittensor wallet to 2.1.3 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2492
+
+## New Contributors
+* @vaqxai made their first contribution in https://github.com/opentensor/bittensor/pull/2366
+* @zyzniewski-reef made their first contribution in https://github.com/opentensor/bittensor/pull/2476
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v8.3.1...v8.4.0
+
## 8.3.1 /2024-11-14
## What's Changed
diff --git a/VERSION b/VERSION
index 905c243928..9da0a092a0 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-8.3.1
\ No newline at end of file
+8.4.0
\ No newline at end of file
diff --git a/bittensor/__main__.py b/bittensor/__main__.py
index 05d664c9de..f9f56b9002 100644
--- a/bittensor/__main__.py
+++ b/bittensor/__main__.py
@@ -15,7 +15,24 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
+import os
+import subprocess
+import sys
+
from bittensor import __version__
if __name__ == "__main__":
- print(f"Bittensor SDK version: {__version__}")
+ if len(sys.argv) > 1 and sys.argv[1] == "certifi":
+ # Resolve the path to certifi.sh
+ certifi_script = os.path.join(os.path.dirname(__file__), "utils", "certifi.sh")
+ if not os.path.exists(certifi_script):
+ print(f"Error: certifi.sh not found at {certifi_script}")
+ sys.exit(1)
+
+ # Ensure the script is executable
+ os.chmod(certifi_script, 0o755)
+
+ # Run the script
+ subprocess.run([certifi_script], check=True)
+ else:
+ print(f"Bittensor SDK version: {__version__}")
diff --git a/bittensor/core/async_subtensor.py b/bittensor/core/async_subtensor.py
index fc59fc121a..e5cdda25c9 100644
--- a/bittensor/core/async_subtensor.py
+++ b/bittensor/core/async_subtensor.py
@@ -132,10 +132,10 @@ def __init__(self, network: str = DEFAULT_NETWORK):
self.network = "custom"
else:
logging.info(
- f"Network not specified or not valid. Using default chain endpoint: {NETWORK_MAP[DEFAULTS.subtensor.network]}."
+ f"Network not specified or not valid. Using default chain endpoint: [blue]{NETWORK_MAP[DEFAULTS.subtensor.network]}[/blue]."
)
logging.info(
- "You can set this for commands with the --network flag, or by setting this in the config."
+ "You can set this for commands with the [blue]--network[/blue] flag, or by setting this in the config."
)
self.chain_endpoint = NETWORK_MAP[DEFAULTS.subtensor.network]
self.network = DEFAULTS.subtensor.network
@@ -152,19 +152,19 @@ def __str__(self):
async def __aenter__(self):
logging.info(
- f"Connecting to Substrate: {self}..."
+ f"[magenta]Connecting to Substrate:[/magenta] [blue]{self}[/blue][magenta]...[/magenta]"
)
try:
async with self.substrate:
return self
except TimeoutException:
logging.error(
- f"Error: Timeout occurred connecting to substrate. Verify your chain and network settings: {self}"
+ f"[red]Error[/red]: Timeout occurred connecting to substrate. Verify your chain and network settings: {self}"
)
raise ConnectionError
except (ConnectionRefusedError, ssl.SSLError) as error:
logging.error(
- f"Error: Connection refused when connecting to substrate. "
+ f"[red]Error[/red]: Connection refused when connecting to substrate. "
f"Verify your chain and network settings: {self}. Error: {error}"
)
raise ConnectionError
@@ -192,6 +192,41 @@ async def encode_params(
return param_data.to_hex()
+ async def get_hyperparameter(
+ self,
+ param_name: str,
+ netuid: int,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
+ ) -> Optional[Any]:
+ """
+ Retrieves a specified hyperparameter for a specific subnet.
+
+ Args:
+ param_name (str): The name of the hyperparameter to retrieve.
+ netuid (int): The unique identifier of the subnet.
+ block_hash (Optional[str]): The hash of blockchain block number for the query.
+ reuse_block (bool): Whether to reuse the last-used block hash.
+
+ Returns:
+ The value of the specified hyperparameter if the subnet exists, or None
+ """
+ if not await self.subnet_exists(netuid, block_hash):
+ logging.error(f"subnet {netuid} does not exist")
+ return None
+
+ result = await self.substrate.query(
+ module="SubtensorModule",
+ storage_function=param_name,
+ params=[netuid],
+ block_hash=block_hash,
+ reuse_block_hash=reuse_block,
+ )
+
+ return result
+
+ # Common subtensor methods =========================================================================================
+
async def get_current_block(self) -> int:
"""
Returns the current block number on the Bittensor blockchain. This function provides the latest block number, indicating the most recent state of the blockchain.
@@ -221,7 +256,10 @@ async def get_block_hash(self, block_id: Optional[int] = None):
return await self.substrate.get_chain_head()
async def is_hotkey_registered_any(
- self, hotkey_ss58: str, block_hash: Optional[str] = None
+ self,
+ hotkey_ss58: str,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> bool:
"""
Checks if a neuron's hotkey is registered on any subnet within the Bittensor network.
@@ -229,22 +267,27 @@ async def is_hotkey_registered_any(
Args:
hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
block_hash (Optional[str]): The blockchain block_hash representation of block id.
+ reuse_block (bool): Whether to reuse the last-used block hash.
Returns:
bool: ``True`` if the hotkey is registered on any subnet, False otherwise.
This function is essential for determining the network-wide presence and participation of a neuron.
"""
- return len(await self.get_netuids_for_hotkey(hotkey_ss58, block_hash)) > 0
+ return (
+ len(await self.get_netuids_for_hotkey(hotkey_ss58, block_hash, reuse_block))
+ > 0
+ )
async def get_subnet_burn_cost(
- self, block_hash: Optional[str] = None
+ self, block_hash: Optional[str] = None, reuse_block: bool = False
) -> Optional[str]:
"""
Retrieves the burn cost for registering a new subnet within the Bittensor network. This cost represents the amount of Tao that needs to be locked or burned to establish a new subnet.
Args:
block_hash (Optional[int]): The blockchain block_hash of the block id.
+ reuse_block (bool): Whether to reuse the last-used block hash.
Returns:
int: The burn cost for subnet registration.
@@ -256,18 +299,20 @@ async def get_subnet_burn_cost(
method="get_network_registration_cost",
params=[],
block_hash=block_hash,
+ reuse_block=reuse_block,
)
return lock_cost
async def get_total_subnets(
- self, block_hash: Optional[str] = None
+ self, block_hash: Optional[str] = None, reuse_block: bool = False
) -> Optional[int]:
"""
Retrieves the total number of subnets within the Bittensor network as of a specific blockchain block.
Args:
block_hash (Optional[str]): The blockchain block_hash representation of block id.
+ reuse_block (bool): Whether to reuse the last-used block hash.
Returns:
Optional[str]: The total number of subnets in the network.
@@ -279,15 +324,19 @@ async def get_total_subnets(
storage_function="TotalNetworks",
params=[],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
return result
- async def get_subnets(self, block_hash: Optional[str] = None) -> list[int]:
+ async def get_subnets(
+ self, block_hash: Optional[str] = None, reuse_block: bool = False
+ ) -> list[int]:
"""
Retrieves the list of all subnet unique identifiers (netuids) currently present in the Bittensor network.
Args:
block_hash (Optional[str]): The hash of the block to retrieve the subnet unique identifiers from.
+ reuse_block (bool): Whether to reuse the last-used block hash.
Returns:
A list of subnet netuids.
@@ -299,7 +348,7 @@ async def get_subnets(self, block_hash: Optional[str] = None) -> list[int]:
module="SubtensorModule",
storage_function="NetworksAdded",
block_hash=block_hash,
- reuse_block_hash=True,
+ reuse_block_hash=reuse_block,
)
return (
[]
@@ -391,7 +440,11 @@ async def get_stake_info_for_coldkey(
return StakeInfo.list_from_vec_u8(hex_to_bytes(hex_bytes_result))
async def get_stake_for_coldkey_and_hotkey(
- self, hotkey_ss58: str, coldkey_ss58: str, block_hash: Optional[str] = None
+ self,
+ hotkey_ss58: str,
+ coldkey_ss58: str,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> Balance:
"""
Retrieves stake information associated with a specific coldkey and hotkey.
@@ -400,6 +453,7 @@ async def get_stake_for_coldkey_and_hotkey(
hotkey_ss58 (str): the hotkey SS58 address to query
coldkey_ss58 (str): the coldkey SS58 address to query
block_hash (Optional[str]): the hash of the blockchain block number for the query.
+ reuse_block (Optional[bool]): whether to reuse the last-used block hash.
Returns:
Stake Balance for the given coldkey and hotkey
@@ -409,6 +463,7 @@ async def get_stake_for_coldkey_and_hotkey(
storage_function="Stake",
params=[hotkey_ss58, coldkey_ss58],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
return Balance.from_rao(_result or 0)
@@ -473,6 +528,7 @@ async def get_balance(
self,
*addresses: str,
block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> dict[str, Balance]:
"""
Retrieves the balance for given coldkey(s)
@@ -480,10 +536,15 @@ async def get_balance(
Args:
addresses (str): coldkey addresses(s).
block_hash (Optional[str]): the block hash, optional.
+ reuse_block (Optional[bool]): whether to reuse the last-used block hash.
Returns:
Dict of {address: Balance objects}.
"""
+ if reuse_block:
+ block_hash = self.substrate.last_block_hash
+ elif not block_hash:
+ block_hash = await self.get_block_hash()
calls = [
(
await self.substrate.create_storage_key(
@@ -533,7 +594,7 @@ async def get_transfer_fee(
)
except Exception as e:
logging.error(
- f":cross_mark: Failed to get payment info: {e}"
+ f":cross_mark: [red]Failed to get payment info: [/red]{e}"
)
payment_info = {"partialFee": int(2e7)} # assume 0.02 Tao
@@ -552,6 +613,7 @@ async def get_total_stake_for_coldkey(
self,
*ss58_addresses,
block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> dict[str, Balance]:
"""
Returns the total stake held on a coldkey.
@@ -559,10 +621,15 @@ async def get_total_stake_for_coldkey(
Args:
ss58_addresses (tuple[str]): The SS58 address(es) of the coldkey(s)
block_hash (str): The hash of the block number to retrieve the stake from.
+ reuse_block (bool): Whether to reuse the last-used block hash.
Returns:
Dict in view {address: Balance objects}.
"""
+ if reuse_block:
+ block_hash = self.substrate.last_block_hash
+ elif not block_hash:
+ block_hash = await self.get_block_hash()
calls = [
(
await self.substrate.create_storage_key(
@@ -663,39 +730,6 @@ async def subnet_exists(
)
return result
- async def get_hyperparameter(
- self,
- param_name: str,
- netuid: int,
- block_hash: Optional[str] = None,
- reuse_block: bool = False,
- ) -> Optional[Any]:
- """
- Retrieves a specified hyperparameter for a specific subnet.
-
- Args:
- param_name (str): The name of the hyperparameter to retrieve.
- netuid (int): The unique identifier of the subnet.
- block_hash (Optional[str]): The hash of blockchain block number for the query.
- reuse_block (bool): Whether to reuse the last-used block hash.
-
- Returns:
- The value of the specified hyperparameter if the subnet exists, or None
- """
- if not await self.subnet_exists(netuid, block_hash):
- print("subnet does not exist")
- return None
-
- result = await self.substrate.query(
- module="SubtensorModule",
- storage_function=param_name,
- params=[netuid],
- block_hash=block_hash,
- reuse_block_hash=reuse_block,
- )
-
- return result
-
async def filter_netuids_by_registered_hotkeys(
self,
all_netuids: Iterable[int],
@@ -781,7 +815,7 @@ async def get_existential_deposit(
return Balance.from_rao(result)
async def neurons(
- self, netuid: int, block_hash: Optional[str] = None
+ self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
) -> list[NeuronInfo]:
"""
Retrieves a list of all neurons within a specified subnet of the Bittensor network.
@@ -790,29 +824,25 @@ async def neurons(
Args:
netuid (int): The unique identifier of the subnet.
block_hash (str): The hash of the blockchain block number for the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
A list of NeuronInfo objects detailing each neuron's characteristics in the subnet.
Understanding the distribution and status of neurons within a subnet is key to comprehending the network's decentralized structure and the dynamics of its consensus and governance processes.
"""
- neurons_lite, weights, bonds = await asyncio.gather(
- self.neurons_lite(netuid=netuid, block_hash=block_hash),
- self.weights(netuid=netuid, block_hash=block_hash),
- self.bonds(netuid=netuid, block_hash=block_hash),
+ hex_bytes_result = await self.query_runtime_api(
+ runtime_api="NeuronInfoRuntimeApi",
+ method="get_neurons",
+ params=[netuid],
+ block_hash=block_hash,
+ reuse_block=reuse_block,
)
- weights_as_dict = {uid: w for uid, w in weights}
- bonds_as_dict = {uid: b for uid, b in bonds}
-
- neurons = [
- NeuronInfo.from_weights_bonds_and_neuron_lite(
- neuron_lite, weights_as_dict, bonds_as_dict
- )
- for neuron_lite in neurons_lite
- ]
+ if hex_bytes_result is None:
+ return []
- return neurons
+ return NeuronInfo.list_from_vec_u8(hex_to_bytes(hex_bytes_result))
async def neurons_lite(
self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
@@ -846,8 +876,54 @@ async def neurons_lite(
return NeuronInfoLite.list_from_vec_u8(hex_to_bytes(hex_bytes_result))
+ async def get_neuron_for_pubkey_and_subnet(
+ self,
+ hotkey_ss58: str,
+ netuid: int,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
+ ) -> "NeuronInfo":
+ """
+ Retrieves information about a neuron based on its public key (hotkey SS58 address) and the specific subnet UID (netuid). This function provides detailed neuron information for a particular subnet within the Bittensor network.
+
+ Args:
+ hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
+ netuid (int): The unique identifier of the subnet.
+ block_hash (Optional[int]): The blockchain block number at which to perform the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
+
+ Returns:
+ Optional[bittensor.core.chain_data.neuron_info.NeuronInfo]: Detailed information about the neuron if found, ``None`` otherwise.
+
+ This function is crucial for accessing specific neuron data and understanding its status, stake, and other attributes within a particular subnet of the Bittensor ecosystem.
+ """
+ uid = await self.substrate.query(
+ module="SubtensorModule",
+ storage_function="Uids",
+ params=[netuid, hotkey_ss58],
+ block_hash=block_hash,
+ reuse_block_hash=reuse_block,
+ )
+ if uid is None:
+ return NeuronInfo.get_null_neuron()
+
+ params = [netuid, uid]
+ json_body = await self.substrate.rpc_request(
+ method="neuronInfo_getNeuron",
+ params=params,
+ )
+
+ if not (result := json_body.get("result", None)):
+ return NeuronInfo.get_null_neuron()
+
+ return NeuronInfo.from_vec_u8(bytes(result))
+
async def neuron_for_uid(
- self, uid: Optional[int], netuid: int, block_hash: Optional[str] = None
+ self,
+ uid: Optional[int],
+ netuid: int,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> NeuronInfo:
"""
Retrieves detailed information about a specific neuron identified by its unique identifier (UID) within a specified subnet (netuid) of the Bittensor network. This function provides a comprehensive view of a neuron's attributes, including its stake, rank, and operational status.
@@ -856,6 +932,7 @@ async def neuron_for_uid(
uid (int): The unique identifier of the neuron.
netuid (int): The unique identifier of the subnet.
block_hash (str): The hash of the blockchain block number for the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
Detailed information about the neuron if found, a null neuron otherwise
@@ -865,6 +942,9 @@ async def neuron_for_uid(
if uid is None:
return NeuronInfo.get_null_neuron()
+ if reuse_block:
+ block_hash = self.substrate.last_block_hash
+
params = [netuid, uid, block_hash] if block_hash else [netuid, uid]
json_body = await self.substrate.rpc_request(
method="neuronInfo_getNeuron",
@@ -948,7 +1028,7 @@ async def query_identity(
return {}
async def weights(
- self, netuid: int, block_hash: Optional[str] = None
+ self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
) -> list[tuple[int, list[tuple[int, int]]]]:
"""
Retrieves the weight distribution set by neurons within a specific subnet of the Bittensor network.
@@ -957,6 +1037,7 @@ async def weights(
Args:
netuid (int): The network UID of the subnet to query.
block_hash (str): The hash of the blockchain block for the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
A list of tuples mapping each neuron's UID to its assigned weights.
@@ -969,13 +1050,14 @@ async def weights(
storage_function="Weights",
params=[netuid],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
w_map = [(uid, w or []) async for uid, w in w_map_encoded]
return w_map
async def bonds(
- self, netuid: int, block_hash: Optional[str] = None
+ self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
) -> list[tuple[int, list[tuple[int, int]]]]:
"""
Retrieves the bond distribution set by neurons within a specific subnet of the Bittensor network.
@@ -984,6 +1066,7 @@ async def bonds(
Args:
netuid (int): The network UID of the subnet to query.
block_hash (Optional[str]): The hash of the blockchain block number for the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
List of tuples mapping each neuron's UID to its bonds with other neurons.
@@ -995,6 +1078,7 @@ async def bonds(
storage_function="Bonds",
params=[netuid],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
b_map = [(uid, b) async for uid, b in b_map_encoded]
@@ -1033,7 +1117,10 @@ async def does_hotkey_exist(
return return_val
async def get_hotkey_owner(
- self, hotkey_ss58: str, block_hash: str
+ self,
+ hotkey_ss58: str,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> Optional[str]:
"""
Retrieves the owner of the given hotkey at a specific block hash.
@@ -1041,7 +1128,8 @@ async def get_hotkey_owner(
Args:
hotkey_ss58 (str): The SS58 address of the hotkey.
- block_hash (str): The hash of the block at which to check the hotkey ownership.
+ block_hash (Optional[str]): The hash of the block at which to check the hotkey ownership.
+ reuse_block (bool): Whether to reuse the last-used blockchain hash.
Returns:
Optional[str]: The SS58 address of the owner if the hotkey exists, or None if it doesn't.
@@ -1051,6 +1139,7 @@ async def get_hotkey_owner(
storage_function="Owner",
params=[hotkey_ss58],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
val = decode_account_id(hk_owner_query[0])
if val:
@@ -1132,7 +1221,7 @@ async def get_children(self, hotkey: str, netuid: int) -> tuple[bool, list, str]
return False, [], format_error_message(e, self.substrate)
async def get_subnet_hyperparameters(
- self, netuid: int, block_hash: Optional[str] = None
+ self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
) -> Optional[Union[list, SubnetHyperparameters]]:
"""
Retrieves the hyperparameters for a specific subnet within the Bittensor network. These hyperparameters define the operational settings and rules governing the subnet's behavior.
@@ -1140,6 +1229,7 @@ async def get_subnet_hyperparameters(
Args:
netuid (int): The network UID of the subnet to query.
block_hash (Optional[str]): The hash of the blockchain block number for the query.
+ reuse_block (bool): Whether to reuse the last-used blockchain hash.
Returns:
The subnet's hyperparameters, or `None` if not available.
@@ -1151,6 +1241,7 @@ async def get_subnet_hyperparameters(
method="get_subnet_hyperparams",
params=[netuid],
block_hash=block_hash,
+ reuse_block=reuse_block,
)
if hex_bytes_result is None:
@@ -1190,13 +1281,14 @@ async def get_vote_data(
return ProposalVoteData(vote_data)
async def get_delegate_identities(
- self, block_hash: Optional[str] = None
+ self, block_hash: Optional[str] = None, reuse_block: bool = False
) -> dict[str, DelegatesDetails]:
"""
Fetches delegates identities from the chain and GitHub. Preference is given to chain data, and missing info is filled-in by the info from GitHub. At some point, we want to totally move away from fetching this info from GitHub, but chain data is still limited in that regard.
Args:
block_hash (str): the hash of the blockchain block for the query
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
Dict {ss58: DelegatesDetails, ...}
@@ -1209,6 +1301,7 @@ async def get_delegate_identities(
module="Registry",
storage_function="IdentityOf",
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
),
session.get(DELEGATES_DETAILS_URL),
)
@@ -1250,12 +1343,20 @@ async def get_delegate_identities(
return all_delegates_details
- async def is_hotkey_registered(self, netuid: int, hotkey_ss58: str) -> bool:
+ async def is_hotkey_registered(
+ self,
+ netuid: int,
+ hotkey_ss58: str,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
+ ) -> bool:
"""Checks to see if the hotkey is registered on a given netuid"""
result = await self.substrate.query(
module="SubtensorModule",
storage_function="Uids",
params=[netuid, hotkey_ss58],
+ block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
if result is not None:
return True
@@ -1263,7 +1364,11 @@ async def is_hotkey_registered(self, netuid: int, hotkey_ss58: str) -> bool:
return False
async def get_uid_for_hotkey_on_subnet(
- self, hotkey_ss58: str, netuid: int, block_hash: Optional[str] = None
+ self,
+ hotkey_ss58: str,
+ netuid: int,
+ block_hash: Optional[str] = None,
+ reuse_block: bool = False,
) -> Optional[int]:
"""
Retrieves the unique identifier (UID) for a neuron's hotkey on a specific subnet.
@@ -1272,6 +1377,7 @@ async def get_uid_for_hotkey_on_subnet(
hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
netuid (int): The unique identifier of the subnet.
block_hash (Optional[str]): The blockchain block_hash representation of the block id.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
Optional[int]: The UID of the neuron if it is registered on the subnet, ``None`` otherwise.
@@ -1283,21 +1389,29 @@ async def get_uid_for_hotkey_on_subnet(
storage_function="Uids",
params=[netuid, hotkey_ss58],
block_hash=block_hash,
+ reuse_block_hash=reuse_block,
)
return result
- async def weights_rate_limit(self, netuid: int) -> Optional[int]:
+ async def weights_rate_limit(
+ self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
+ ) -> Optional[int]:
"""
Returns network WeightsSetRateLimit hyperparameter.
Args:
netuid (int): The unique identifier of the subnetwork.
+ block_hash (Optional[str]): The blockchain block_hash representation of the block id.
+ reuse_block (bool): Whether to reuse the last-used blockchain block hash.
Returns:
Optional[int]: The value of the WeightsSetRateLimit hyperparameter, or ``None`` if the subnetwork does not exist or the parameter is not found.
"""
call = await self.get_hyperparameter(
- param_name="WeightsSetRateLimit", netuid=netuid
+ param_name="WeightsSetRateLimit",
+ netuid=netuid,
+ block_hash=block_hash,
+ reuse_block=reuse_block,
)
return None if call is None else int(call)
@@ -1315,7 +1429,7 @@ async def blocks_since_last_update(self, netuid: int, uid: int) -> Optional[int]
call = await self.get_hyperparameter(param_name="LastUpdate", netuid=netuid)
return None if call is None else await self.get_current_block() - int(call[uid])
- # extrinsics
+ # Extrinsics =======================================================================================================
async def transfer(
self,
@@ -1366,7 +1480,7 @@ async def register(
`True` if registration was successful, otherwise `False`.
"""
logging.info(
- f"Registering on netuid 0 on network: {self.network}"
+ f"Registering on netuid [blue]0[/blue] on network: [blue]{self.network}[/blue]"
)
# Check current recycle amount
@@ -1389,7 +1503,7 @@ async def register(
# Check balance is sufficient
if balance < current_recycle:
logging.error(
- f"Insufficient balance {balance} to register neuron. Current recycle is {current_recycle} TAO."
+ f"[red]Insufficient balance {balance} to register neuron. Current recycle is {current_recycle} TAO[/red]."
)
return False
@@ -1467,7 +1581,7 @@ async def set_weights(
) > await self.weights_rate_limit(netuid):
try:
logging.info(
- f"Setting weights for subnet #{netuid}. Attempt {retries + 1} of {max_retries}."
+ f"Setting weights for subnet #[blue]{netuid}[/blue]. Attempt [blue]{retries + 1} of {max_retries}[/blue]."
)
success, message = await set_weights_extrinsic(
subtensor=self,
@@ -1505,7 +1619,7 @@ async def root_set_weights(
"""
netuids_ = np.array(netuids, dtype=np.int64)
weights_ = np.array(weights, dtype=np.float32)
- logging.info(f"Setting weights in network: {self.network}")
+ logging.info(f"Setting weights in network: [blue]{self.network}[/blue]")
# Run the set weights operation.
return await set_root_weights_extrinsic(
subtensor=self,
diff --git a/bittensor/core/axon.py b/bittensor/core/axon.py
index ce967acb80..378315f77d 100644
--- a/bittensor/core/axon.py
+++ b/bittensor/core/axon.py
@@ -59,7 +59,7 @@
from bittensor.core.stream import StreamingSynapse
from bittensor.core.synapse import Synapse, TerminalInfo
from bittensor.core.threadpool import PriorityThreadPoolExecutor
-from bittensor.utils import networking
+from bittensor.utils import networking, Certificate
from bittensor.utils.axon_utils import allowed_nonce_window_ns, calculate_diff_seconds
from bittensor.utils.btlogging import logging
@@ -807,7 +807,12 @@ def stop(self) -> "Axon":
self.started = False
return self
- def serve(self, netuid: int, subtensor: Optional["Subtensor"] = None) -> "Axon":
+ def serve(
+ self,
+ netuid: int,
+ subtensor: Optional["Subtensor"] = None,
+ certificate: Optional[Certificate] = None,
+ ) -> "Axon":
"""
Serves the Axon on the specified subtensor connection using the configured wallet. This method
registers the Axon with a specific subnet within the Bittensor network, identified by the ``netuid``.
@@ -832,7 +837,7 @@ def serve(self, netuid: int, subtensor: Optional["Subtensor"] = None) -> "Axon":
to start receiving and processing requests from other neurons.
"""
if subtensor is not None and hasattr(subtensor, "serve_axon"):
- subtensor.serve_axon(netuid=netuid, axon=self)
+ subtensor.serve_axon(netuid=netuid, axon=self, certificate=certificate)
return self
async def default_verify(self, synapse: "Synapse"):
diff --git a/bittensor/core/chain_data/__init__.py b/bittensor/core/chain_data/__init__.py
index 68936a6b5f..760eaa3354 100644
--- a/bittensor/core/chain_data/__init__.py
+++ b/bittensor/core/chain_data/__init__.py
@@ -11,6 +11,7 @@
from .ip_info import IPInfo
from .neuron_info import NeuronInfo
from .neuron_info_lite import NeuronInfoLite
+from .neuron_certificate import NeuronCertificate
from .prometheus_info import PrometheusInfo
from .proposal_vote_data import ProposalVoteData
from .scheduled_coldkey_swap_info import ScheduledColdkeySwapInfo
diff --git a/bittensor/core/chain_data/neuron_certificate.py b/bittensor/core/chain_data/neuron_certificate.py
new file mode 100644
index 0000000000..a20f377d38
--- /dev/null
+++ b/bittensor/core/chain_data/neuron_certificate.py
@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import List
+
+from bittensor.core.chain_data.utils import from_scale_encoding, ChainDataType
+from bittensor.utils import Certificate
+
+
+# Dataclasses for chain data.
+@dataclass
+class NeuronCertificate:
+ """
+ Dataclass for neuron certificate.
+ """
+
+ certificate: Certificate
+
+ @classmethod
+ def from_vec_u8(cls, vec_u8: List[int]) -> "NeuronCertificate":
+ """Returns a NeuronCertificate object from a ``vec_u8``."""
+ return from_scale_encoding(vec_u8, ChainDataType.NeuronCertificate)
diff --git a/bittensor/core/chain_data/neuron_info.py b/bittensor/core/chain_data/neuron_info.py
index 478cdfa4c9..ecc1b2488c 100644
--- a/bittensor/core/chain_data/neuron_info.py
+++ b/bittensor/core/chain_data/neuron_info.py
@@ -174,3 +174,57 @@ def from_vec_u8(cls, vec_u8: bytes) -> "NeuronInfo":
),
is_null=False,
)
+
+ @classmethod
+ def list_from_vec_u8(cls, vec_u8: bytes) -> list["NeuronInfo"]:
+ nn = bt_decode.NeuronInfo.decode_vec(bytes(vec_u8))
+
+ def fix(n):
+ stake_dict = process_stake_data(n.stake)
+ total_stake = sum(stake_dict.values()) if stake_dict else Balance(0)
+ axon_info = n.axon_info
+ coldkey = decode_account_id(n.coldkey)
+ hotkey = decode_account_id(n.hotkey)
+ return NeuronInfo(
+ hotkey=hotkey,
+ coldkey=coldkey,
+ uid=n.uid,
+ netuid=n.netuid,
+ active=n.active,
+ stake=total_stake,
+ stake_dict=stake_dict,
+ total_stake=total_stake,
+ rank=u16_normalized_float(n.rank),
+ emission=n.emission / 1e9,
+ incentive=u16_normalized_float(n.incentive),
+ consensus=u16_normalized_float(n.consensus),
+ trust=u16_normalized_float(n.trust),
+ validator_trust=u16_normalized_float(n.validator_trust),
+ dividends=u16_normalized_float(n.dividends),
+ last_update=n.last_update,
+ validator_permit=n.validator_permit,
+ weights=[[e[0], e[1]] for e in n.weights],
+ bonds=[[e[0], e[1]] for e in n.bonds],
+ pruning_score=n.pruning_score,
+ prometheus_info=PrometheusInfo(
+ block=n.prometheus_info.block,
+ version=n.prometheus_info.version,
+ ip=str(netaddr.IPAddress(n.prometheus_info.ip)),
+ port=n.prometheus_info.port,
+ ip_type=n.prometheus_info.ip_type,
+ ),
+ axon_info=AxonInfo(
+ version=axon_info.version,
+ ip=str(netaddr.IPAddress(axon_info.ip)),
+ port=axon_info.port,
+ ip_type=axon_info.ip_type,
+ placeholder1=axon_info.placeholder1,
+ placeholder2=axon_info.placeholder2,
+ protocol=axon_info.protocol,
+ hotkey=hotkey,
+ coldkey=coldkey,
+ ),
+ is_null=False,
+ )
+
+ return [fix(n) for n in nn]
diff --git a/bittensor/core/chain_data/utils.py b/bittensor/core/chain_data/utils.py
index 9c21c9d22e..1218b9ea56 100644
--- a/bittensor/core/chain_data/utils.py
+++ b/bittensor/core/chain_data/utils.py
@@ -22,6 +22,7 @@ class ChainDataType(Enum):
SubnetHyperparameters = 8
ScheduledColdkeySwapInfo = 9
AccountId = 10
+ NeuronCertificate = 11
def from_scale_encoding(
@@ -178,6 +179,12 @@ def from_scale_encoding_using_type_string(
["pruning_score", "Compact"],
],
},
+ "NeuronCertificate": {
+ "type": "struct",
+ "type_mapping": [
+ ["certificate", "Vec"],
+ ],
+ },
"axon_info": {
"type": "struct",
"type_mapping": [
diff --git a/bittensor/core/extrinsics/async_registration.py b/bittensor/core/extrinsics/async_registration.py
index a0901a5639..e9d5aff5e5 100644
--- a/bittensor/core/extrinsics/async_registration.py
+++ b/bittensor/core/extrinsics/async_registration.py
@@ -1,426 +1,96 @@
+"""
+This module provides 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.
+"""
+
import asyncio
-import binascii
-import functools
-import hashlib
-import io
-import math
-import multiprocessing as mp
-import os
-import random
-import subprocess
-import time
-from contextlib import redirect_stdout
-from dataclasses import dataclass
-from datetime import timedelta
-from multiprocessing import Process, Event, Lock, Array, Value, Queue
-from multiprocessing.queues import Queue as Queue_Type
-from queue import Empty, Full
-from typing import Optional, Union, TYPE_CHECKING, Callable, Any
+from typing import Optional, Union, TYPE_CHECKING
-import backoff
-import numpy as np
-from Crypto.Hash import keccak
from bittensor_wallet import Wallet
-from rich.console import Console
-from rich.status import Status
-from substrateinterface.exceptions import SubstrateRequestException
-from bittensor.core.chain_data import NeuronInfo
-from bittensor.utils import format_error_message, unlock_key
+from bittensor.utils import format_error_message
from bittensor.utils.btlogging import logging
-from bittensor.utils.formatting import millify, get_human_readable
+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.core.async_subtensor import AsyncSubtensor
+ from bittensor.utils.registration.pow import POWSolution
+else:
+ from bittensor.utils.registration.pow import LazyLoadedTorch
+ torch = LazyLoadedTorch()
-# TODO: compair and remove existing code (bittensor.utils.registration)
-
-
-def use_torch() -> bool:
- """Force the use of torch over numpy for certain operations."""
- return True if os.getenv("USE_TORCH") == "1" else False
-
-
-def legacy_torch_api_compat(func: Callable):
- """
- Convert function operating on numpy Input&Output to legacy torch Input&Output API if `use_torch()` is True.
-
- Args:
- func: Function with numpy Input/Output to be decorated.
-
- Returns:
- Decorated function
- """
-
- @functools.wraps(func)
- def decorated(*args, **kwargs):
- if use_torch():
- # if argument is a Torch tensor, convert it to numpy
- args = [
- arg.cpu().numpy() if isinstance(arg, torch.Tensor) else arg
- for arg in args
- ]
- kwargs = {
- key: value.cpu().numpy() if isinstance(value, torch.Tensor) else value
- for key, value in kwargs.items()
- }
- ret = func(*args, **kwargs)
- if use_torch():
- # if return value is a numpy array, convert it to Torch tensor
- if isinstance(ret, np.ndarray):
- ret = torch.from_numpy(ret)
- return ret
-
- return decorated
-
-
-@functools.cache
-def _get_real_torch():
- try:
- import torch as _real_torch
- except ImportError:
- _real_torch = None
- return _real_torch
-
-
-def log_no_torch_error():
- logging.info(
- "This command requires torch. You can install torch with `pip install torch` and run the command again."
- )
-
-
-@dataclass
-class POWSolution:
- """A solution to the registration PoW problem."""
-
- nonce: int
- block_number: int
- difficulty: int
- seal: bytes
-
- async def is_stale(self, subtensor: "AsyncSubtensor") -> bool:
- """
- Returns True if the POW is stale.
-
- This means the block the POW is solved for is within 3 blocks of the current block.
- """
- current_block = await subtensor.substrate.get_block_number(None)
- return self.block_number < current_block - 3
-
-
-@dataclass
-class RegistrationStatistics:
- """Statistics for a registration."""
-
- time_spent_total: float
- rounds_total: int
- time_average: float
- time_spent: float
- hash_rate_perpetual: float
- hash_rate: float
- difficulty: int
- block_number: int
- block_hash: str
-
-
-class RegistrationStatisticsLogger:
- """Logs statistics for a registration."""
-
- console: Console
- status: Optional[Status]
-
- def __init__(
- self, console_: Optional["Console"] = None, output_in_place: bool = True
- ) -> None:
- if console_ is None:
- console_ = Console()
- self.console = console_
-
- if output_in_place:
- self.status = self.console.status("Solving")
- else:
- self.status = None
-
- def start(self) -> None:
- if self.status is not None:
- self.status.start()
- def stop(self) -> None:
- if self.status is not None:
- self.status.stop()
+class MaxSuccessException(Exception):
+ """Raised when the POW Solver has reached the max number of successful solutions."""
- @classmethod
- def get_status_message(
- cls, stats: RegistrationStatistics, verbose: bool = False
- ) -> str:
- """Provides a message of the current status of the block solving as a str for a logger or stdout."""
- message = (
- "Solving\n"
- + f"Time Spent (total): [bold white]{timedelta(seconds=stats.time_spent_total)}[/bold white]\n"
- + (
- f"Time Spent This Round: {timedelta(seconds=stats.time_spent)}\n"
- + f"Time Spent Average: {timedelta(seconds=stats.time_average)}\n"
- if verbose
- else ""
- )
- + f"Registration Difficulty: [bold white]{millify(stats.difficulty)}[/bold white]\n"
- + f"Iters (Inst/Perp): [bold white]{get_human_readable(stats.hash_rate, 'H')}/s / "
- + f"{get_human_readable(stats.hash_rate_perpetual, 'H')}/s[/bold white]\n"
- + f"Block Number: [bold white]{stats.block_number}[/bold white]\n"
- + f"Block Hash: [bold white]{stats.block_hash.encode('utf-8')}[/bold white]\n"
- )
- return message
- def update(self, stats: RegistrationStatistics, verbose: bool = False) -> None:
- """Passes the current status to the logger."""
- if self.status is not None:
- self.status.update(self.get_status_message(stats, verbose=verbose))
- else:
- self.console.log(self.get_status_message(stats, verbose=verbose))
+class MaxAttemptsException(Exception):
+ """Raised when the POW Solver has reached the max number of attempts."""
-class _SolverBase(Process):
- """
- A process that solves the registration PoW problem.
+async def _do_pow_register(
+ subtensor: "AsyncSubtensor",
+ netuid: int,
+ wallet: "Wallet",
+ pow_result: "POWSolution",
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = True,
+) -> tuple[bool, Optional[str]]:
+ """Sends a (POW) register extrinsic to the chain.
Args:
- proc_num: The number of the process being created.
- num_proc: The total number of processes running.
- update_interval: The number of nonces to try to solve before checking for a new block.
- finished_queue: The queue to put the process number when a process finishes each update_interval. Used for calculating the average time per update_interval across all processes.
- solution_queue: The queue to put the solution the process has found during the pow solve.
- stop_event: The event to set by the main process when all the solver processes should stop. The solver process will check for the event after each update_interval. The solver process will stop when the event is set. Used to stop the solver processes when a solution is found.
- curr_block: The array containing this process's current block hash. The main process will set the array to the new block hash when a new block is finalized in the network. The solver process will get the new block hash from this array when newBlockEvent is set
- curr_block_num: The value containing this process's current block number. The main process will set the value to the new block number when a new block is finalized in the network. The solver process will get the new block number from this value when new_block_event is set.
- curr_diff: The array containing this process's current difficulty. The main process will set the array to the new difficulty when a new block is finalized in the network. The solver process will get the new difficulty from this array when newBlockEvent is set.
- check_block: The lock to prevent this process from getting the new block data while the main process is updating the data.
- limit: The limit of the pow solve for a valid solution.
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The subtensor to send the extrinsic to.
+ netuid (int): The subnet to register on.
+ wallet (bittensor.wallet): The wallet to register.
+ pow_result (POWSolution): The PoW result to register.
+ wait_for_inclusion (bool): If ``True``, waits for the extrinsic to be included in a block. Default to `False`.
+ wait_for_finalization (bool): If ``True``, waits for the extrinsic to be finalized. Default to `True`.
Returns:
- new_block_event: The event to set by the main process when a new block is finalized in the network. The solver process will check for the event after each update_interval. The solver process will get the new block hash and difficulty and start solving for a new nonce.
+ success (bool): ``True`` if the extrinsic was included in a block.
+ error (Optional[str]): ``None`` on success or not waiting for inclusion/finalization, otherwise the error message.
"""
+ # create extrinsic call
+ call = await subtensor.substrate.compose_call(
+ call_module="SubtensorModule",
+ call_function="register",
+ call_params={
+ "netuid": netuid,
+ "block_number": pow_result.block_number,
+ "nonce": pow_result.nonce,
+ "work": [int(byte_) for byte_ in pow_result.seal],
+ "hotkey": wallet.hotkey.ss58_address,
+ "coldkey": wallet.coldkeypub.ss58_address,
+ },
+ )
+ extrinsic = await subtensor.substrate.create_signed_extrinsic(
+ call=call, keypair=wallet.hotkey
+ )
+ response = await subtensor.substrate.submit_extrinsic(
+ extrinsic=extrinsic,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
- proc_num: int
- num_proc: int
- update_interval: int
- finished_queue: Queue_Type
- solution_queue: Queue_Type
- new_block_event: Event
- stop_event: Event
- hotkey_bytes: bytes
- curr_block: Array
- curr_block_num: Value
- curr_diff: Array
- check_block: Lock
- limit: int
-
- def __init__(
- self,
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stop_event,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- ):
- Process.__init__(self, daemon=True)
- self.proc_num = proc_num
- self.num_proc = num_proc
- self.update_interval = update_interval
- self.finished_queue = finished_queue
- self.solution_queue = solution_queue
- self.new_block_event = Event()
- self.new_block_event.clear()
- self.curr_block = curr_block
- self.curr_block_num = curr_block_num
- self.curr_diff = curr_diff
- self.check_block = check_block
- self.stop_event = stop_event
- self.limit = limit
-
- def run(self):
- raise NotImplementedError("_SolverBase is an abstract class")
-
- @staticmethod
- def create_shared_memory() -> tuple[Array, Value, Array]:
- """Creates shared memory for the solver processes to use."""
- curr_block = Array("h", 32, lock=True) # byte array
- curr_block_num = Value("i", 0, lock=True) # int
- curr_diff = Array("Q", [0, 0], lock=True) # [high, low]
-
- return curr_block, curr_block_num, curr_diff
-
-
-class _Solver(_SolverBase):
- """Performs POW Solution."""
-
- def run(self):
- block_number: int
- block_and_hotkey_hash_bytes: bytes
- block_difficulty: int
- nonce_limit = int(math.pow(2, 64)) - 1
-
- # Start at random nonce
- nonce_start = random.randint(0, nonce_limit)
- nonce_end = nonce_start + self.update_interval
- while not self.stop_event.is_set():
- if self.new_block_event.is_set():
- with self.check_block:
- block_number = self.curr_block_num.value
- block_and_hotkey_hash_bytes = bytes(self.curr_block)
- block_difficulty = _registration_diff_unpack(self.curr_diff)
-
- self.new_block_event.clear()
-
- # Do a block of nonces
- solution = _solve_for_nonce_block(
- nonce_start,
- nonce_end,
- block_and_hotkey_hash_bytes,
- block_difficulty,
- self.limit,
- block_number,
- )
- if solution is not None:
- self.solution_queue.put(solution)
-
- try:
- # Send time
- self.finished_queue.put_nowait(self.proc_num)
- except Full:
- pass
-
- nonce_start = random.randint(0, nonce_limit)
- nonce_start = nonce_start % nonce_limit
- nonce_end = nonce_start + self.update_interval
-
-
-class _CUDASolver(_SolverBase):
- """Performs POW Solution using CUDA."""
-
- dev_id: int
- tpb: int
+ # We only wait here if we expect finalization.
+ if not wait_for_finalization and not wait_for_inclusion:
+ return True, None
- def __init__(
- self,
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stop_event,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- dev_id: int,
- tpb: int,
- ):
- super().__init__(
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stop_event,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
+ # process if registration successful, try again if pow is still valid
+ await response.process_events()
+ if not await response.is_success:
+ return False, format_error_message(
+ error_message=await response.error_message, substrate=subtensor.substrate
)
- self.dev_id = dev_id
- self.tpb = tpb
-
- def run(self):
- block_number: int = 0 # dummy value
- block_and_hotkey_hash_bytes: bytes = b"0" * 32 # dummy value
- block_difficulty: int = int(math.pow(2, 64)) - 1 # dummy value
- nonce_limit = int(math.pow(2, 64)) - 1 # U64MAX
-
- # Start at random nonce
- nonce_start = random.randint(0, nonce_limit)
- while not self.stop_event.is_set():
- if self.new_block_event.is_set():
- with self.check_block:
- block_number = self.curr_block_num.value
- block_and_hotkey_hash_bytes = bytes(self.curr_block)
- block_difficulty = _registration_diff_unpack(self.curr_diff)
-
- self.new_block_event.clear()
-
- # Do a block of nonces
- solution = _solve_for_nonce_block_cuda(
- nonce_start,
- self.update_interval,
- block_and_hotkey_hash_bytes,
- block_difficulty,
- self.limit,
- block_number,
- self.dev_id,
- self.tpb,
- )
- if solution is not None:
- self.solution_queue.put(solution)
-
- try:
- # Signal that a nonce_block was finished using queue
- # send our proc_num
- self.finished_queue.put(self.proc_num)
- except Full:
- pass
-
- # increase nonce by number of nonces processed
- nonce_start += self.update_interval * self.tpb
- nonce_start = nonce_start % nonce_limit
-
-
-class LazyLoadedTorch:
- def __bool__(self):
- return bool(_get_real_torch())
-
- def __getattr__(self, name):
- if real_torch := _get_real_torch():
- return getattr(real_torch, name)
- else:
- log_no_torch_error()
- raise ImportError("torch not installed")
-
-
-if TYPE_CHECKING:
- import torch
-else:
- torch = LazyLoadedTorch()
-
-
-class MaxSuccessException(Exception):
- """Raised when the POW Solver has reached the max number of successful solutions."""
-
-
-class MaxAttemptsException(Exception):
- """Raised when the POW Solver has reached the max number of attempts."""
-
-
-async def is_hotkey_registered(
- subtensor: "AsyncSubtensor", netuid: int, hotkey_ss58: str
-) -> bool:
- """Checks to see if the hotkey is registered on a given netuid"""
- _result = await subtensor.substrate.query(
- module="SubtensorModule",
- storage_function="Uids",
- params=[netuid, hotkey_ss58],
- )
- if _result is not None:
- return True
+ # Successful registration
else:
- return False
+ return True, None
async def register_extrinsic(
@@ -459,61 +129,51 @@ async def register_extrinsic(
`True` if extrinsic was finalized or included in the block. If we did not wait for finalization/inclusion, the response is `True`.
"""
- async def get_neuron_for_pubkey_and_subnet():
- uid = await subtensor.substrate.query(
- "SubtensorModule", "Uids", [netuid, wallet.hotkey.ss58_address]
- )
- if uid is None:
- return NeuronInfo.get_null_neuron()
-
- params = [netuid, uid]
- json_body = await subtensor.substrate.rpc_request(
- method="neuronInfo_getNeuron",
- params=params,
- )
-
- if not (result := json_body.get("result", None)):
- return NeuronInfo.get_null_neuron()
-
- return NeuronInfo.from_vec_u8(bytes(result))
-
- logging.debug("Checking subnet status")
+ logging.debug("[magenta]Checking subnet status... [/magenta]")
if not await subtensor.subnet_exists(netuid):
logging.error(
- f":cross_mark: Failed error: subnet {netuid} does not exist."
+ f":cross_mark: [red]Failed error:[/red] subnet [blue]{netuid}[/blue] does not exist."
)
return False
logging.info(
- f":satellite: Checking Account on subnet {netuid} ..."
+ f":satellite: [magenta]Checking Account on subnet[/magenta] [blue]{netuid}[/blue] [magenta]...[/magenta]"
+ )
+ neuron = await subtensor.get_neuron_for_pubkey_and_subnet(
+ hotkey_ss58=wallet.hotkey.ss58_address,
+ netuid=netuid,
)
- neuron = await get_neuron_for_pubkey_and_subnet()
+
if not neuron.is_null:
logging.debug(
- f"Wallet {wallet} is already registered on subnet {neuron.netuid} with uid{neuron.uid}."
+ f"Wallet [green]{wallet}[/green] is already registered on subnet [blue]{neuron.netuid}[/blue] with uid[blue]{neuron.uid}[/blue]."
)
return True
+ logging.debug(
+ f"Registration hotkey: {wallet.hotkey.ss58_address}, Public coldkey: {wallet.coldkey.ss58_address} in the network: {subtensor.network}."
+ )
+
if not torch:
log_no_torch_error()
return False
# Attempt rolling registration.
attempts = 1
- pow_result: Optional[POWSolution]
+
while True:
logging.info(
- f":satellite: Registering... ({attempts}/{max_allowed_attempts})"
+ f":satellite: [magenta]Registering...[/magenta] [blue]({attempts}/{max_allowed_attempts})[/blue]"
)
# Solve latest POW.
if cuda:
if not torch.cuda.is_available():
return False
- pow_result = await create_pow(
- subtensor,
- wallet,
- netuid,
- output_in_place,
+ pow_result = await create_pow_async(
+ subtensor=subtensor,
+ wallet=wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
cuda=cuda,
dev_id=dev_id,
tpb=tpb,
@@ -522,11 +182,11 @@ async def get_neuron_for_pubkey_and_subnet():
log_verbose=log_verbose,
)
else:
- pow_result = await create_pow(
- subtensor,
- wallet,
- netuid,
- output_in_place,
+ pow_result = await create_pow_async(
+ subtensor=subtensor,
+ wallet=wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
cuda=cuda,
num_processes=num_processes,
update_interval=update_interval,
@@ -536,1024 +196,72 @@ async def get_neuron_for_pubkey_and_subnet():
# pow failed
if not pow_result:
# might be registered already on this subnet
- is_registered = await is_hotkey_registered(
- subtensor, netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
+ is_registered = await subtensor.is_hotkey_registered(
+ netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
)
if is_registered:
logging.error(
- f":white_heavy_check_mark: Already registered on netuid: {netuid}"
+ f":white_heavy_check_mark: [green]Already registered on netuid:[/green] [blue]{netuid}[/blue]"
)
return True
# pow successful, proceed to submit pow to chain for registration
else:
- logging.info(":satellite: Submitting POW...")
+ logging.info(":satellite: [magenta]Submitting POW...[/magenta]")
# check if pow result is still valid
- while not await pow_result.is_stale(subtensor=subtensor):
- call = await subtensor.substrate.compose_call(
- call_module="SubtensorModule",
- call_function="register",
- call_params={
- "netuid": netuid,
- "block_number": pow_result.block_number,
- "nonce": pow_result.nonce,
- "work": [int(byte_) for byte_ in pow_result.seal],
- "hotkey": wallet.hotkey.ss58_address,
- "coldkey": wallet.coldkeypub.ss58_address,
- },
- )
- extrinsic = await subtensor.substrate.create_signed_extrinsic(
- call=call, keypair=wallet.hotkey
- )
- response = await subtensor.substrate.submit_extrinsic(
- extrinsic,
+ while not await pow_result.is_stale_async(subtensor=subtensor):
+ result: tuple[bool, Optional[str]] = await _do_pow_register(
+ subtensor=subtensor,
+ netuid=netuid,
+ wallet=wallet,
+ pow_result=pow_result,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
)
- 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 = (
- False,
- format_error_message(
- await response.error_message,
- substrate=subtensor.substrate,
- ),
- )
- # Look error here
- # https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
- if "HotKeyAlreadyRegisteredInSubNet" in err_msg:
- logging.info(
- f":white_heavy_check_mark: Already Registered on subnet: {netuid}."
- )
- return True
- logging.error(f":cross_mark: Failed: {err_msg}")
- await asyncio.sleep(0.5)
+ success, err_msg = result
+ if not success:
+ # Look error here
+ # https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
+
+ if "HotKeyAlreadyRegisteredInSubNet" in err_msg:
+ logging.info(
+ f":white_heavy_check_mark: [green]Already Registered on subnet:[/green] [blue]{netuid}[/blue]."
+ )
+ return True
+ logging.error(f":cross_mark: [red]Failed[/red]: {err_msg}")
+ await asyncio.sleep(0.5)
# Successful registration, final check for neuron and pubkey
if success:
logging.info(":satellite: Checking Registration status...")
- is_registered = await is_hotkey_registered(
- subtensor,
- netuid=netuid,
- hotkey_ss58=wallet.hotkey.ss58_address,
+ is_registered = await subtensor.is_hotkey_registered(
+ netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
)
if is_registered:
logging.success(
- ":white_heavy_check_mark: Registered"
+ ":white_heavy_check_mark: [green]Registered[/green]"
)
return True
else:
# neuron not found, try again
logging.error(
- ":cross_mark: Unknown error. Neuron not found."
+ ":cross_mark: [red]Unknown error. Neuron not found.[/red]"
)
continue
else:
# Exited loop because pow is no longer valid.
- logging.error("POW is stale.")
+ logging.error("[red]POW is stale.[/red]")
# Try again.
- continue
+ # continue
if attempts < max_allowed_attempts:
# Failed registration, retry pow
attempts += 1
logging.error(
- f":satellite: Failed registration, retrying pow ... ({attempts}/{max_allowed_attempts})"
+ f":satellite: [magenta]Failed registration, retrying pow ...[/magenta] [blue]({attempts}/{max_allowed_attempts})[/blue]"
)
else:
# Failed to register after max attempts.
- logging.error("No more attempts.")
+ logging.error("[red]No more attempts.[/red]")
return False
-
-
-async def run_faucet_extrinsic(
- subtensor: "AsyncSubtensor",
- wallet: Wallet,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = True,
- max_allowed_attempts: int = 3,
- output_in_place: bool = True,
- cuda: bool = False,
- dev_id: int = 0,
- tpb: int = 256,
- num_processes: Optional[int] = None,
- update_interval: Optional[int] = None,
- log_verbose: bool = False,
- max_successes: int = 3,
-) -> tuple[bool, str]:
- """Runs a continual POW to get a faucet of TAO on the test net.
-
- Args:
- subtensor: The subtensor interface object used to run the extrinsic
- wallet: Bittensor wallet object.
- 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.
- 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.
- max_allowed_attempts: Maximum number of attempts to register the wallet.
- output_in_place: Whether to output logging data as the process runs.
- cuda: If `True`, the wallet should be registered using CUDA device(s).
- dev_id: The CUDA device id to use
- tpb: The number of threads per block (CUDA).
- num_processes: The number of processes to use to register.
- update_interval: The number of nonces to solve between updates.
- log_verbose: If `True`, the registration process will log more information.
- max_successes: The maximum number of successful faucet runs for the wallet.
-
- Returns:
- `True` if extrinsic was finalized or included in the block. If we did not wait for finalization/inclusion, the response is also `True`
- """
-
- if not torch:
- log_no_torch_error()
- return False, "Requires torch"
-
- # Unlock coldkey
- if not (unlock := unlock_key(wallet)).success:
- return False, unlock.message
-
- # Get previous balance.
- old_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
-
- # Attempt rolling registration.
- attempts = 1
- successes = 1
- while True:
- try:
- pow_result = None
- while pow_result is None or await pow_result.is_stale(subtensor=subtensor):
- # Solve latest POW.
- if cuda:
- if not torch.cuda.is_available():
- return False, "CUDA is not available."
- pow_result: Optional[POWSolution] = await create_pow(
- subtensor,
- wallet,
- -1,
- output_in_place,
- cuda=cuda,
- dev_id=dev_id,
- tpb=tpb,
- num_processes=num_processes,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
- else:
- pow_result: Optional[POWSolution] = await create_pow(
- subtensor,
- wallet,
- -1,
- output_in_place,
- cuda=cuda,
- num_processes=num_processes,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
- call = await subtensor.substrate.compose_call(
- call_module="SubtensorModule",
- call_function="faucet",
- call_params={
- "block_number": pow_result.block_number,
- "nonce": pow_result.nonce,
- "work": [int(byte_) for byte_ in pow_result.seal],
- },
- )
- extrinsic = await subtensor.substrate.create_signed_extrinsic(
- call=call, keypair=wallet.coldkey
- )
- response = await subtensor.substrate.submit_extrinsic(
- extrinsic,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
-
- # process if registration successful, try again if pow is still valid
- await response.process_events()
- if not await response.is_success:
- logging.error(
- f":cross_mark: Failed: {format_error_message(await response.error_message, subtensor.substrate)}"
- )
- if attempts == max_allowed_attempts:
- raise MaxAttemptsException
- attempts += 1
- # Wait a bit before trying again
- time.sleep(1)
-
- # Successful registration
- else:
- new_balance = await subtensor.get_balance(
- wallet.coldkeypub.ss58_address
- )
- logging.info(
- f"Balance: {old_balance[wallet.coldkeypub.ss58_address]} :arrow_right: {new_balance[wallet.coldkeypub.ss58_address]}"
- )
- old_balance = new_balance
-
- if successes == max_successes:
- raise MaxSuccessException
-
- attempts = 1 # Reset attempts on success
- successes += 1
-
- except KeyboardInterrupt:
- return True, "Done"
-
- except MaxSuccessException:
- return True, f"Max successes reached: {3}"
-
- except MaxAttemptsException:
- return False, f"Max attempts reached: {max_allowed_attempts}"
-
-
-async def _check_for_newest_block_and_update(
- subtensor: "AsyncSubtensor",
- netuid: int,
- old_block_number: int,
- hotkey_bytes: bytes,
- curr_diff: Array,
- curr_block: Array,
- curr_block_num: Value,
- update_curr_block: "Callable",
- check_block: Lock,
- solvers: list[_Solver],
- curr_stats: "RegistrationStatistics",
-) -> int:
- """
- Checks for a new block and updates the current block information if a new block is found.
-
- Args:
- subtensor: The subtensor object to use for getting the current block.
- netuid: The netuid to use for retrieving the difficulty.
- old_block_number: The old block number to check against.
- hotkey_bytes: The bytes of the hotkey's pubkey.
- curr_diff: The current difficulty as a multiprocessing array.
- curr_block: Where the current block is stored as a multiprocessing array.
- curr_block_num: Where the current block number is stored as a multiprocessing value.
- update_curr_block: A function that updates the current block.
- check_block: A mp lock that is used to check for a new block.
- solvers: A list of solvers to update the current block for.
- curr_stats: The current registration statistics to update.
-
- Returns:
- The current block number.
- """
- block_number = await subtensor.substrate.get_block_number(None)
- if block_number != old_block_number:
- old_block_number = block_number
- # update block information
- block_number, difficulty, block_hash = await _get_block_with_retry(
- subtensor=subtensor, netuid=netuid
- )
- block_bytes = bytes.fromhex(block_hash[2:])
-
- update_curr_block(
- curr_diff,
- curr_block,
- curr_block_num,
- block_number,
- block_bytes,
- difficulty,
- hotkey_bytes,
- check_block,
- )
- # Set new block events for each solver
-
- for worker in solvers:
- worker.new_block_event.set()
-
- # update stats
- curr_stats.block_number = block_number
- curr_stats.block_hash = block_hash
- curr_stats.difficulty = difficulty
-
- return old_block_number
-
-
-async def _block_solver(
- subtensor: "AsyncSubtensor",
- wallet: Wallet,
- num_processes: int,
- netuid: int,
- dev_id: list[int],
- tpb: int,
- update_interval: int,
- curr_block,
- curr_block_num,
- curr_diff,
- n_samples,
- alpha_,
- output_in_place,
- log_verbose,
- cuda: bool,
-):
- """Shared code used by the Solvers to solve the POW solution."""
- limit = int(math.pow(2, 256)) - 1
-
- # Establish communication queues
- # See the _Solver class for more information on the queues.
- stop_event = Event()
- stop_event.clear()
-
- solution_queue = Queue()
- finished_queues = [Queue() for _ in range(num_processes)]
- check_block = Lock()
-
- hotkey_bytes = (
- wallet.coldkeypub.public_key if netuid == -1 else wallet.hotkey.public_key
- )
-
- if cuda:
- # Create a worker per CUDA device
- num_processes = len(dev_id)
- solvers = [
- _CUDASolver(
- i,
- num_processes,
- update_interval,
- finished_queues[i],
- solution_queue,
- stop_event,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- dev_id[i],
- tpb,
- )
- for i in range(num_processes)
- ]
- else:
- # Start consumers
- solvers = [
- _Solver(
- i,
- num_processes,
- update_interval,
- finished_queues[i],
- solution_queue,
- stop_event,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- )
- for i in range(num_processes)
- ]
-
- # Get first block
- block_number, difficulty, block_hash = await _get_block_with_retry(
- subtensor=subtensor, netuid=netuid
- )
-
- block_bytes = bytes.fromhex(block_hash[2:])
- old_block_number = block_number
- # Set to current block
- _update_curr_block(
- curr_diff,
- curr_block,
- curr_block_num,
- block_number,
- block_bytes,
- difficulty,
- hotkey_bytes,
- check_block,
- )
-
- # Set new block events for each solver to start at the initial block
- for worker in solvers:
- worker.new_block_event.set()
-
- for worker in solvers:
- worker.start() # start the solver processes
-
- start_time = time.time() # time that the registration started
- time_last = start_time # time that the last work blocks completed
-
- curr_stats = RegistrationStatistics(
- time_spent_total=0.0,
- time_average=0.0,
- rounds_total=0,
- time_spent=0.0,
- hash_rate_perpetual=0.0,
- hash_rate=0.0,
- difficulty=difficulty,
- block_number=block_number,
- block_hash=block_hash,
- )
-
- start_time_perpetual = time.time()
-
- logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
- logger.start()
-
- solution = None
-
- hash_rates = [0] * n_samples # The last n true hash_rates
- weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
-
- timeout = 0.15 if cuda else 0.15
- while netuid == -1 or not await is_hotkey_registered(
- subtensor, netuid, wallet.hotkey.ss58_address
- ):
- # Wait until a solver finds a solution
- try:
- solution = solution_queue.get(block=True, timeout=timeout)
- if solution is not None:
- break
- except Empty:
- # No solution found, try again
- pass
-
- # check for new block
- old_block_number = await _check_for_newest_block_and_update(
- subtensor=subtensor,
- netuid=netuid,
- hotkey_bytes=hotkey_bytes,
- old_block_number=old_block_number,
- curr_diff=curr_diff,
- curr_block=curr_block,
- curr_block_num=curr_block_num,
- curr_stats=curr_stats,
- update_curr_block=_update_curr_block,
- check_block=check_block,
- solvers=solvers,
- )
-
- num_time = 0
- for finished_queue in finished_queues:
- try:
- finished_queue.get(timeout=0.1)
- num_time += 1
-
- except Empty:
- continue
-
- time_now = time.time() # get current time
- time_since_last = time_now - time_last # get time since last work block(s)
- if num_time > 0 and time_since_last > 0.0:
- # create EWMA of the hash_rate to make measure more robust
-
- if cuda:
- hash_rate_ = (num_time * tpb * update_interval) / time_since_last
- else:
- hash_rate_ = (num_time * update_interval) / time_since_last
- hash_rates.append(hash_rate_)
- hash_rates.pop(0) # remove the 0th data point
- curr_stats.hash_rate = sum(
- [hash_rates[i] * weights[i] for i in range(n_samples)]
- ) / (sum(weights))
-
- # update time last to now
- time_last = time_now
-
- curr_stats.time_average = (
- curr_stats.time_average * curr_stats.rounds_total
- + curr_stats.time_spent
- ) / (curr_stats.rounds_total + num_time)
- curr_stats.rounds_total += num_time
-
- # Update stats
- curr_stats.time_spent = time_since_last
- new_time_spent_total = time_now - start_time_perpetual
- if cuda:
- curr_stats.hash_rate_perpetual = (
- curr_stats.rounds_total * (tpb * update_interval)
- ) / new_time_spent_total
- else:
- curr_stats.hash_rate_perpetual = (
- curr_stats.rounds_total * update_interval
- ) / new_time_spent_total
- curr_stats.time_spent_total = new_time_spent_total
-
- # Update the logger
- logger.update(curr_stats, verbose=log_verbose)
-
- # exited while, solution contains the nonce or wallet is registered
- stop_event.set() # stop all other processes
- logger.stop()
-
- # terminate and wait for all solvers to exit
- _terminate_workers_and_wait_for_exit(solvers)
-
- return solution
-
-
-async def _solve_for_difficulty_fast_cuda(
- subtensor: "AsyncSubtensor",
- wallet: Wallet,
- netuid: int,
- output_in_place: bool = True,
- update_interval: int = 50_000,
- tpb: int = 512,
- dev_id: Union[list[int], int] = 0,
- n_samples: int = 10,
- alpha_: float = 0.80,
- log_verbose: bool = False,
-) -> Optional["POWSolution"]:
- """
- Solves the registration fast using CUDA
-
- Args:
- subtensor: The subtensor node to grab blocks
- wallet: The wallet to register
- netuid: The netuid of the subnet to register to.
- output_in_place: If true, prints the output in place, otherwise prints to new lines
- update_interval: The number of nonces to try before checking for more blocks
- tpb: The number of threads per block. CUDA param that should match the GPU capability
- dev_id: The CUDA device IDs to execute the registration on, either a single device or a list of devices
- n_samples: The number of samples of the hash_rate to keep for the EWMA
- alpha_: The alpha for the EWMA for the hash_rate calculation
- log_verbose: If true, prints more verbose logging of the registration metrics.
-
- Note:
- The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
- """
- if isinstance(dev_id, int):
- dev_id = [dev_id]
- elif dev_id is None:
- dev_id = [0]
-
- if update_interval is None:
- update_interval = 50_000
-
- if not torch.cuda.is_available():
- raise Exception("CUDA not available")
-
- # Set mp start to use spawn so CUDA doesn't complain
- with _UsingSpawnStartMethod(force=True):
- curr_block, curr_block_num, curr_diff = _CUDASolver.create_shared_memory()
-
- solution = await _block_solver(
- subtensor=subtensor,
- wallet=wallet,
- num_processes=None,
- netuid=netuid,
- dev_id=dev_id,
- tpb=tpb,
- update_interval=update_interval,
- curr_block=curr_block,
- curr_block_num=curr_block_num,
- curr_diff=curr_diff,
- n_samples=n_samples,
- alpha_=alpha_,
- output_in_place=output_in_place,
- log_verbose=log_verbose,
- cuda=True,
- )
-
- return solution
-
-
-async def _solve_for_difficulty_fast(
- subtensor,
- wallet: Wallet,
- netuid: int,
- output_in_place: bool = True,
- num_processes: Optional[int] = None,
- update_interval: Optional[int] = None,
- n_samples: int = 10,
- alpha_: float = 0.80,
- log_verbose: bool = False,
-) -> Optional[POWSolution]:
- """
- Solves the POW for registration using multiprocessing.
-
- Args:
- subtensor: Subtensor to connect to for block information and to submit.
- wallet: wallet to use for registration.
- netuid: The netuid of the subnet to register to.
- output_in_place: If true, prints the status in place. Otherwise, prints the status on a new line.
- num_processes: Number of processes to use.
- update_interval: Number of nonces to solve before updating block information.
- n_samples: The number of samples of the hash_rate to keep for the EWMA
- alpha_: The alpha for the EWMA for the hash_rate calculation
- log_verbose: If true, prints more verbose logging of the registration metrics.
-
- Notes:
- The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
- We can also modify the update interval to do smaller blocks of work, while still updating the block information after a different number of nonces, to increase the transparency of the process while still keeping the speed.
- """
- if not num_processes:
- # get the number of allowed processes for this process
- num_processes = min(1, get_cpu_count())
-
- if update_interval is None:
- update_interval = 50_000
-
- curr_block, curr_block_num, curr_diff = _Solver.create_shared_memory()
-
- solution = await _block_solver(
- subtensor=subtensor,
- wallet=wallet,
- num_processes=num_processes,
- netuid=netuid,
- dev_id=None,
- tpb=None,
- update_interval=update_interval,
- curr_block=curr_block,
- curr_block_num=curr_block_num,
- curr_diff=curr_diff,
- n_samples=n_samples,
- alpha_=alpha_,
- output_in_place=output_in_place,
- log_verbose=log_verbose,
- cuda=False,
- )
-
- return solution
-
-
-def _terminate_workers_and_wait_for_exit(
- workers: list[Union[Process, Queue_Type]],
-) -> None:
- for worker in workers:
- if isinstance(worker, Queue_Type):
- worker.join_thread()
- else:
- try:
- worker.join(3.0)
- except subprocess.TimeoutExpired:
- worker.terminate()
- try:
- worker.close()
- except ValueError:
- worker.terminate()
-
-
-# TODO verify this works with async
-@backoff.on_exception(backoff.constant, Exception, interval=1, max_tries=3)
-async def _get_block_with_retry(
- subtensor: "AsyncSubtensor", netuid: int
-) -> tuple[int, int, bytes]:
- """
- Gets the current block number, difficulty, and block hash from the substrate node.
-
- Args:
- subtensor: The subtensor object to use to get the block number, difficulty, and block hash.
- netuid: The netuid of the network to get the block number, difficulty, and block hash from.
-
- Returns:
- The current block number, difficulty of the subnet, block hash
-
- Raises:
- Exception: If the block hash is None.
- ValueError: If the difficulty is None.
- """
- block_number = await subtensor.substrate.get_block_number(None)
- block_hash = await subtensor.substrate.get_block_hash(
- block_number
- ) # TODO check if I need to do all this
- try:
- difficulty = (
- 1_000_000
- if netuid == -1
- else int(
- await subtensor.get_hyperparameter(
- param_name="Difficulty", netuid=netuid, block_hash=block_hash
- )
- )
- )
- except TypeError:
- raise ValueError("Chain error. Difficulty is None")
- except SubstrateRequestException:
- raise Exception(
- "Network error. Could not connect to substrate to get block hash"
- )
- return block_number, difficulty, block_hash
-
-
-def _registration_diff_unpack(packed_diff: Array) -> int:
- """Unpacks the packed two 32-bit integers into one 64-bit integer. Little endian."""
- return int(packed_diff[0] << 32 | packed_diff[1])
-
-
-def _registration_diff_pack(diff: int, packed_diff: Array):
- """Packs the difficulty into two 32-bit integers. Little endian."""
- packed_diff[0] = diff >> 32
- packed_diff[1] = diff & 0xFFFFFFFF # low 32 bits
-
-
-class _UsingSpawnStartMethod:
- def __init__(self, force: bool = False):
- self._old_start_method = None
- self._force = force
-
- def __enter__(self):
- self._old_start_method = mp.get_start_method(allow_none=True)
- if self._old_start_method is None:
- self._old_start_method = "spawn" # default to spawn
-
- mp.set_start_method("spawn", force=self._force)
-
- def __exit__(self, *args):
- # restore the old start method
- mp.set_start_method(self._old_start_method, force=True)
-
-
-async def create_pow(
- subtensor: "AsyncSubtensor",
- wallet: Wallet,
- netuid: int,
- output_in_place: bool = True,
- cuda: bool = False,
- dev_id: Union[list[int], int] = 0,
- tpb: int = 256,
- num_processes: int = None,
- update_interval: int = None,
- log_verbose: bool = False,
-) -> Optional[dict[str, Any]]:
- """
- Creates a proof of work for the given subtensor and wallet.
-
- Args:
- subtensor: The subtensor to create a proof of work for.
- wallet: The wallet to create a proof of work for.
- netuid: The netuid for the subnet to create a proof of work for.
- output_in_place: If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines.
- cuda: If true, uses CUDA to solve the proof of work.
- dev_id: The CUDA device id(s) to use. If cuda is true and dev_id is a list, then multiple CUDA devices will be used to solve the proof of work.
- tpb: The number of threads per block to use when solving the proof of work. Should be a multiple of 32.
- num_processes: The number of processes to use when solving the proof of work. If None, then the number of processes is equal to the number of CPU cores.
- update_interval: The number of nonces to run before checking for a new block.
- log_verbose: If true, prints the progress of the proof of work more verbosely.
-
- Returns:
- The proof of work solution or None if the wallet is already registered or there is a different error.
-
- Raises:
- ValueError: If the subnet does not exist.
- """
- if netuid != -1:
- if not await subtensor.subnet_exists(netuid=netuid):
- raise ValueError(f"Subnet {netuid} does not exist")
-
- if cuda:
- solution: Optional[POWSolution] = await _solve_for_difficulty_fast_cuda(
- subtensor,
- wallet,
- netuid=netuid,
- output_in_place=output_in_place,
- dev_id=dev_id,
- tpb=tpb,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
- else:
- solution: Optional[POWSolution] = await _solve_for_difficulty_fast(
- subtensor,
- wallet,
- netuid=netuid,
- output_in_place=output_in_place,
- num_processes=num_processes,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
-
- return solution
-
-
-def _solve_for_nonce_block_cuda(
- nonce_start: int,
- update_interval: int,
- block_and_hotkey_hash_bytes: bytes,
- difficulty: int,
- limit: int,
- block_number: int,
- dev_id: int,
- tpb: int,
-) -> Optional[POWSolution]:
- """
- Tries to solve the POW on a CUDA device for a block of nonces (nonce_start, nonce_start + update_interval * tpb
- """
- solution, seal = solve_cuda(
- nonce_start,
- update_interval,
- tpb,
- block_and_hotkey_hash_bytes,
- difficulty,
- limit,
- dev_id,
- )
-
- if solution != -1:
- # Check if solution is valid (i.e. not -1)
- return POWSolution(solution, block_number, difficulty, seal)
-
- return None
-
-
-def _solve_for_nonce_block(
- nonce_start: int,
- nonce_end: int,
- block_and_hotkey_hash_bytes: bytes,
- difficulty: int,
- limit: int,
- block_number: int,
-) -> Optional[POWSolution]:
- """
- Tries to solve the POW for a block of nonces (nonce_start, nonce_end)
- """
- for nonce in range(nonce_start, nonce_end):
- # Create seal.
- seal = _create_seal_hash(block_and_hotkey_hash_bytes, nonce)
-
- # Check if seal meets difficulty
- if _seal_meets_difficulty(seal, difficulty, limit):
- # Found a solution, save it.
- return POWSolution(nonce, block_number, difficulty, seal)
-
- return None
-
-
-class CUDAException(Exception):
- """An exception raised when an error occurs in the CUDA environment."""
-
-
-def _hex_bytes_to_u8_list(hex_bytes: bytes):
- hex_chunks = [int(hex_bytes[i : i + 2], 16) for i in range(0, len(hex_bytes), 2)]
- return hex_chunks
-
-
-def _create_seal_hash(block_and_hotkey_hash_bytes: bytes, nonce: int) -> bytes:
- """
- Create a cryptographic seal hash from the given block and hotkey hash bytes and nonce.
-
- This function generates a seal hash by combining the given block and hotkey hash bytes with a nonce.
- It first converts the nonce to a byte representation, then concatenates it with the first 64 hex characters of the block and hotkey hash bytes. The result is then hashed using SHA-256 followed by the Keccak-256 algorithm to produce the final seal hash.
-
- Args:
- block_and_hotkey_hash_bytes (bytes): The combined hash bytes of the block and hotkey.
- nonce (int): The nonce value used for hashing.
-
- Returns:
- The resulting seal hash.
- """
- nonce_bytes = binascii.hexlify(nonce.to_bytes(8, "little"))
- pre_seal = nonce_bytes + binascii.hexlify(block_and_hotkey_hash_bytes)[:64]
- seal_sh256 = hashlib.sha256(bytearray(_hex_bytes_to_u8_list(pre_seal))).digest()
- kec = keccak.new(digest_bits=256)
- seal = kec.update(seal_sh256).digest()
- return seal
-
-
-def _seal_meets_difficulty(seal: bytes, difficulty: int, limit: int) -> bool:
- """Determines if a seal meets the specified difficulty"""
- seal_number = int.from_bytes(seal, "big")
- product = seal_number * difficulty
- return product < limit
-
-
-def _hash_block_with_hotkey(block_bytes: bytes, hotkey_bytes: bytes) -> bytes:
- """Hashes the block with the hotkey using Keccak-256 to get 32 bytes"""
- kec = keccak.new(digest_bits=256)
- kec = kec.update(bytearray(block_bytes + hotkey_bytes))
- block_and_hotkey_hash_bytes = kec.digest()
- return block_and_hotkey_hash_bytes
-
-
-def _update_curr_block(
- curr_diff: Array,
- curr_block: Array,
- curr_block_num: Value,
- block_number: int,
- block_bytes: bytes,
- diff: int,
- hotkey_bytes: bytes,
- lock: Lock,
-):
- """
- Update the current block data with the provided block information and difficulty.
-
- This function updates the current block and its difficulty in a thread-safe manner. It sets the current block
- number, hashes the block with the hotkey, updates the current block bytes, and packs the difficulty.
-
- curr_diff: Shared array to store the current difficulty.
- curr_block: Shared array to store the current block data.
- curr_block_num: Shared value to store the current block number.
- block_number: The block number to set as the current block number.
- block_bytes: The block data bytes to be hashed with the hotkey.
- diff: The difficulty value to be packed into the current difficulty array.
- hotkey_bytes: The hotkey bytes used for hashing the block.
- lock: A lock to ensure thread-safe updates.
- """
- with lock:
- curr_block_num.value = block_number
- # Hash the block with the hotkey
- block_and_hotkey_hash_bytes = _hash_block_with_hotkey(block_bytes, hotkey_bytes)
- for i in range(32):
- curr_block[i] = block_and_hotkey_hash_bytes[i]
- _registration_diff_pack(diff, curr_diff)
-
-
-def get_cpu_count() -> int:
- try:
- return len(os.sched_getaffinity(0))
- except AttributeError:
- # macOS does not have sched_getaffinity
- return os.cpu_count()
-
-
-@dataclass
-class RegistrationStatistics:
- """Statistics for a registration."""
-
- time_spent_total: float
- rounds_total: int
- time_average: float
- time_spent: float
- hash_rate_perpetual: float
- hash_rate: float
- difficulty: int
- block_number: int
- block_hash: bytes
-
-
-def solve_cuda(
- nonce_start: np.int64,
- update_interval: np.int64,
- tpb: int,
- block_and_hotkey_hash_bytes: bytes,
- difficulty: int,
- limit: int,
- dev_id: int = 0,
-) -> tuple[np.int64, bytes]:
- """
- Solves the PoW problem using CUDA.
-
- nonce_start: Starting nonce.
- update_interval: Number of nonces to solve before updating block information.
- tpb: Threads per block.
- block_and_hotkey_hash_bytes: Keccak(Bytes of the block hash + bytes of the hotkey) 64 bytes.
- difficulty: Difficulty of the PoW problem.
- limit: Upper limit of the nonce.
- dev_id: The CUDA device ID
-
- :return: (nonce, seal) corresponding to the solution. Returns -1 for nonce if no solution is found.
- """
-
- try:
- import cubit
- except ImportError:
- raise ImportError("Please install cubit")
-
- upper = int(limit // difficulty)
-
- upper_bytes = upper.to_bytes(32, byteorder="little", signed=False)
-
- # Call cython function
- # int blockSize, uint64 nonce_start, uint64 update_interval, const unsigned char[:] limit,
- # const unsigned char[:] block_bytes, int dev_id
- block_and_hotkey_hash_hex = binascii.hexlify(block_and_hotkey_hash_bytes)[:64]
-
- solution = cubit.solve_cuda(
- tpb,
- nonce_start,
- update_interval,
- upper_bytes,
- block_and_hotkey_hash_hex,
- dev_id,
- ) # 0 is first GPU
- seal = None
- if solution != -1:
- seal = _create_seal_hash(block_and_hotkey_hash_hex, solution)
- if _seal_meets_difficulty(seal, difficulty, limit):
- return solution, seal
- else:
- return -1, b"\x00" * 32
-
- return solution, seal
-
-
-def reset_cuda():
- """
- Resets the CUDA environment.
- """
- try:
- import cubit
- except ImportError:
- raise ImportError("Please install cubit")
-
- cubit.reset_cuda()
-
-
-def log_cuda_errors() -> str:
- """
- Logs any CUDA errors.
- """
- try:
- import cubit
- except ImportError:
- raise ImportError("Please install cubit")
-
- f = io.StringIO()
- with redirect_stdout(f):
- cubit.log_cuda_errors()
-
- s = f.getvalue()
-
- return s
diff --git a/bittensor/core/extrinsics/async_root.py b/bittensor/core/extrinsics/async_root.py
index 2bf8a4c714..d6f5fa1a59 100644
--- a/bittensor/core/extrinsics/async_root.py
+++ b/bittensor/core/extrinsics/async_root.py
@@ -18,7 +18,7 @@
from bittensor.core.async_subtensor import AsyncSubtensor
-async def get_limits(subtensor: "AsyncSubtensor") -> tuple[int, float]:
+async def _get_limits(subtensor: "AsyncSubtensor") -> tuple[int, float]:
"""
Retrieves the minimum allowed weights and maximum weight limit for the given subnet.
@@ -67,18 +67,18 @@ async def root_register_extrinsic(
return False
logging.debug(
- f"Checking if hotkey ({wallet.hotkey_str}) is registered on root."
+ f"Checking if hotkey ([blue]{wallet.hotkey_str}[/blue]) is registered on root."
)
is_registered = await subtensor.is_hotkey_registered(
netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
)
if is_registered:
logging.error(
- ":white_heavy_check_mark: Already registered on root network."
+ ":white_heavy_check_mark: [green]Already registered on root network.[/green]"
)
return True
- logging.info(":satellite: Registering to root network...")
+ logging.info(":satellite: [magenta]Registering to root network...[/magenta]")
call = await subtensor.substrate.compose_call(
call_module="SubtensorModule",
call_function="root_register",
@@ -92,7 +92,7 @@ async def root_register_extrinsic(
)
if not success:
- logging.error(f":cross_mark: Failed error: {err_msg}")
+ logging.error(f":cross_mark: [red]Failed error:[/red] {err_msg}")
time.sleep(0.5)
return False
@@ -105,15 +105,77 @@ async def root_register_extrinsic(
)
if uid is not None:
logging.info(
- f":white_heavy_check_mark: Registered with UID {uid}."
+ f":white_heavy_check_mark: [green]Registered with UID[/green] [blue]{uid}[/blue]."
)
return True
else:
# neuron not found, try again
- logging.error(":cross_mark: Unknown error. Neuron not found.")
+ logging.error(":cross_mark: [red]Unknown error. Neuron not found.[/red]")
return False
+async def _do_set_root_weights(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ netuids: Union[NDArray[np.int64], list[int]],
+ weights: Union[NDArray[np.float32], list[float]],
+ version_key: int = 0,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+ """
+ Sets the root weights on the Subnet for the given wallet hotkey account.
+
+ This function constructs and submits an extrinsic to set the root weights for the given wallet hotkey account.
+ It waits for inclusion or finalization of the extrinsic based on the provided parameters.
+
+ Arguments:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The AsyncSubtensor object used to interact with the blockchain.
+ 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.
+ 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.
+
+ Returns:
+ tuple: Returns a tuple containing a boolean indicating success and a message describing the result of the operation.
+ """
+ call = await subtensor.substrate.compose_call(
+ call_module="SubtensorModule",
+ call_function="set_root_weights",
+ call_params={
+ "dests": netuids,
+ "weights": weights,
+ "netuid": 0,
+ "version_key": version_key,
+ "hotkey": wallet.hotkey.ss58_address,
+ },
+ )
+ # Period dictates how long the extrinsic will stay as part of waiting pool
+ extrinsic = await subtensor.substrate.create_signed_extrinsic(
+ call=call,
+ keypair=wallet.coldkey,
+ era={"period": 5},
+ )
+ response = await subtensor.substrate.submit_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, "Not waiting for finalization or inclusion."
+
+ await response.process_events()
+ if await response.is_success:
+ return True, "Successfully set weights."
+ else:
+ return False, format_error_message(
+ await response.error_message, substrate=subtensor.substrate
+ )
+
+
async def set_root_weights_extrinsic(
subtensor: "AsyncSubtensor",
wallet: "Wallet",
@@ -137,40 +199,6 @@ async def set_root_weights_extrinsic(
Returns:
`True` if extrinsic was finalized or included in the block. If we did not wait for finalization/inclusion, the response is `True`.
"""
-
- async def _do_set_weights():
- call = await subtensor.substrate.compose_call(
- call_module="SubtensorModule",
- call_function="set_root_weights",
- call_params={
- "dests": weight_uids,
- "weights": weight_vals,
- "netuid": 0,
- "version_key": version_key,
- "hotkey": wallet.hotkey.ss58_address,
- },
- )
- # Period dictates how long the extrinsic will stay as part of waiting pool
- extrinsic = await subtensor.substrate.create_signed_extrinsic(
- call=call,
- keypair=wallet.coldkey,
- era={"period": 5},
- )
- response = await subtensor.substrate.submit_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, "Not waiting for finalization or inclusion."
-
- await response.process_events()
- if await response.is_success:
- return True, "Successfully set weights."
- else:
- return False, await response.error_message
-
my_uid = await subtensor.substrate.query(
"SubtensorModule", "Uids", [0, wallet.hotkey.ss58_address]
)
@@ -190,7 +218,7 @@ async def _do_set_weights():
weights = np.array(weights, dtype=np.float32)
logging.debug("Fetching weight limits")
- min_allowed_weights, max_weight_limit = await get_limits(subtensor)
+ min_allowed_weights, max_weight_limit = await _get_limits(subtensor)
# Get non zero values.
non_zero_weight_idx = np.argwhere(weights > 0).squeeze(axis=1)
@@ -206,27 +234,35 @@ async def _do_set_weights():
logging.info("Normalizing weights")
formatted_weights = normalize_max_weight(x=weights, limit=max_weight_limit)
logging.info(
- f"Raw weights -> Normalized weights: {weights} -> {formatted_weights}"
+ f"Raw weights -> Normalized weights: [blue]{weights}[/blue] -> [green]{formatted_weights}[/green]"
)
try:
- logging.info(":satellite: Setting root weights...")
+ logging.info(":satellite: [magenta]Setting root weights...[magenta]")
weight_uids, weight_vals = convert_weights_and_uids_for_emit(netuids, weights)
- success, error_message = await _do_set_weights()
+ success, error_message = await _do_set_root_weights(
+ subtensor=subtensor,
+ wallet=wallet,
+ netuids=weight_uids,
+ weights=weight_vals,
+ version_key=version_key,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
if not wait_for_finalization and not wait_for_inclusion:
return True
if success is True:
- logging.info(":white_heavy_check_mark: Finalized")
+ logging.info(":white_heavy_check_mark: [green]Finalized[/green]")
return True
else:
- fmt_err = format_error_message(error_message, subtensor.substrate)
- logging.error(f":cross_mark: Failed error: {fmt_err}")
+ fmt_err = error_message
+ logging.error(f":cross_mark: [red]Failed error:[/red] {fmt_err}")
return False
except SubstrateRequestException as e:
fmt_err = format_error_message(e, subtensor.substrate)
- logging.error(f":cross_mark: Failed error: {fmt_err}")
+ logging.error(f":cross_mark: [red]Failed error:[/red] {fmt_err}")
return False
diff --git a/bittensor/core/extrinsics/async_transfer.py b/bittensor/core/extrinsics/async_transfer.py
index e4190023d0..b9de1d4f4e 100644
--- a/bittensor/core/extrinsics/async_transfer.py
+++ b/bittensor/core/extrinsics/async_transfer.py
@@ -1,9 +1,6 @@
import asyncio
from typing import TYPE_CHECKING
-from bittensor_wallet import Wallet
-from substrateinterface.exceptions import SubstrateRequestException
-
from bittensor.core.settings import NETWORK_EXPLORER_MAP
from bittensor.utils import (
format_error_message,
@@ -16,11 +13,66 @@
if TYPE_CHECKING:
from bittensor.core.async_subtensor import AsyncSubtensor
+ from bittensor_wallet import Wallet
+
+
+async def _do_transfer(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ destination: str,
+ amount: "Balance",
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> tuple[bool, str, str]:
+ """
+ Makes transfer from wallet to destination public key address.
+
+ Args:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): initialized AsyncSubtensor object used for transfer
+ wallet (bittensor_wallet.Wallet): Bittensor wallet object to make transfer from.
+ destination (str): Destination public key address (ss58_address or ed25519) of recipient.
+ amount (bittensor.utils.balance.Balance): Amount to stake as Bittensor balance.
+ 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, block hash, formatted error message
+ """
+ call = await subtensor.substrate.compose_call(
+ call_module="Balances",
+ call_function="transfer_allow_death",
+ call_params={"dest": destination, "value": amount.rao},
+ )
+ extrinsic = await subtensor.substrate.create_signed_extrinsic(
+ call=call, keypair=wallet.coldkey
+ )
+ response = await subtensor.substrate.submit_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, "", "Success, extrinsic submitted without waiting."
+
+ # Otherwise continue with finalization.
+ await response.process_events()
+ if await response.is_success:
+ block_hash_ = response.block_hash
+ return True, block_hash_, "Success with response."
+ else:
+ return (
+ False,
+ "",
+ format_error_message(
+ await response.error_message, substrate=subtensor.substrate
+ ),
+ )
async def transfer_extrinsic(
subtensor: "AsyncSubtensor",
- wallet: Wallet,
+ wallet: "Wallet",
destination: str,
amount: "Balance",
transfer_all: bool = False,
@@ -43,75 +95,10 @@ async def transfer_extrinsic(
Returns:
success (bool): Flag is `True` if extrinsic was finalized or included in the block. If we did not wait for finalization / inclusion, the response is `True`, regardless of its inclusion.
"""
-
- async def get_transfer_fee() -> Balance:
- """
- Calculates the transaction fee for transferring tokens from a wallet to a specified destination address.
- This function simulates the transfer to estimate the associated cost, taking into account the current
- network conditions and transaction complexity.
- """
- call = await subtensor.substrate.compose_call(
- call_module="Balances",
- call_function="transfer_allow_death",
- call_params={"dest": destination, "value": amount.rao},
- )
-
- try:
- payment_info = await subtensor.substrate.get_payment_info(
- call=call, keypair=wallet.coldkeypub
- )
- except SubstrateRequestException as e:
- payment_info = {"partialFee": int(2e7)} # assume 0.02 Tao
- logging.error(f":cross_mark: Failed to get payment info:")
- logging.error(f"\t\t{format_error_message(e, subtensor.substrate)}")
- logging.error(
- f"\t\tDefaulting to default transfer fee: {payment_info['partialFee']}"
- )
-
- return Balance.from_rao(payment_info["partialFee"])
-
- async def do_transfer() -> tuple[bool, str, str]:
- """
- Makes transfer from wallet to destination public key address.
-
- Returns:
- success, block hash, formatted error message
- """
- call = await subtensor.substrate.compose_call(
- call_module="Balances",
- call_function="transfer_allow_death",
- call_params={"dest": destination, "value": amount.rao},
- )
- extrinsic = await subtensor.substrate.create_signed_extrinsic(
- call=call, keypair=wallet.coldkey
- )
- response = await subtensor.substrate.submit_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, "", ""
-
- # Otherwise continue with finalization.
- await response.process_events()
- if await response.is_success:
- block_hash_ = response.block_hash
- return True, block_hash_, ""
- else:
- return (
- False,
- "",
- format_error_message(
- await response.error_message, substrate=subtensor.substrate
- ),
- )
-
# Validate destination address.
if not is_valid_bittensor_address_or_public_key(destination):
logging.error(
- f":cross_mark: Invalid destination SS58 address: {destination}"
+ f":cross_mark: [red]Invalid destination SS58 address[/red]: {destination}"
)
return False
logging.info(f"Initiating transfer on network: {subtensor.network}")
@@ -122,7 +109,7 @@ async def do_transfer() -> tuple[bool, str, str]:
# Check balance.
logging.info(
- f":satellite: Checking balance and fees on chain {subtensor.network}"
+ f":satellite: [magenta]Checking balance and fees on chain [/magenta] [blue]{subtensor.network}[/blue]"
)
# check existential deposit and fee
logging.debug("Fetching existential and fee")
@@ -132,7 +119,9 @@ async def do_transfer() -> tuple[bool, str, str]:
subtensor.get_existential_deposit(block_hash=block_hash),
)
account_balance = account_balance_[wallet.coldkeypub.ss58_address]
- fee = await get_transfer_fee()
+ fee = await subtensor.get_transfer_fee(
+ wallet=wallet, dest=destination, value=amount.rao
+ )
if not keep_alive:
# Check if the transfer should keep_alive the account
@@ -146,18 +135,25 @@ async def do_transfer() -> tuple[bool, str, str]:
return False
if account_balance < (amount + fee + existential_deposit):
- logging.error(":cross_mark: Not enough balance")
- logging.error(f"\t\tBalance:\t{account_balance}")
- logging.error(f"\t\tAmount:\t{amount}")
- logging.error(f"\t\tFor fee:\t{fee}")
+ logging.error(":cross_mark: [red]Not enough balance[/red]")
+ logging.error(f"\t\tBalance:\t[blue]{account_balance}[/blue]")
+ logging.error(f"\t\tAmount:\t[blue]{amount}[/blue]")
+ logging.error(f"\t\tFor fee:\t[blue]{fee}[/blue]")
return False
- logging.info(":satellite: Transferring...")
- logging.info(f"[green]Block Hash: {block_hash}")
+ logging.success(":white_heavy_check_mark: [green]Finalized[/green]")
+ logging.info(f"[green]Block Hash:[/green] [blue]{block_hash}[/blue]")
if subtensor.network == "finney":
logging.debug("Fetching explorer URLs")
@@ -166,22 +162,18 @@ async def do_transfer() -> tuple[bool, str, str]:
)
if explorer_urls != {} and explorer_urls:
logging.info(
- f"[green]Opentensor Explorer Link: {explorer_urls.get('opentensor')}"
+ f"[green]Opentensor Explorer Link: {explorer_urls.get('opentensor')}[/green]"
)
logging.info(
- f"[green]Taostats Explorer Link: {explorer_urls.get('taostats')}"
+ f"[green]Taostats Explorer Link: {explorer_urls.get('taostats')}[/green]"
)
- else:
- logging.error(f":cross_mark: Failed: {err_msg}")
- if success:
- logging.info(":satellite: Checking Balance...")
- new_balance = await subtensor.get_balance(
- wallet.coldkeypub.ss58_address, reuse_block=False
- )
+ logging.info(":satellite: [magenta]Checking Balance...[magenta]")
+ new_balance = await subtensor.get_balance(wallet.coldkeypub.ss58_address)
logging.info(
- f"Balance: [blue]{account_balance} :arrow_right: [green]{new_balance[wallet.coldkeypub.ss58_address]}"
+ f"Balance: [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance[wallet.coldkeypub.ss58_address]}[/green]"
)
return True
-
- return False
+ else:
+ logging.error(f":cross_mark: [red]Failed[/red]: {err_msg}")
+ return False
diff --git a/bittensor/core/extrinsics/async_weights.py b/bittensor/core/extrinsics/async_weights.py
index 926ce94c2c..fdac280646 100644
--- a/bittensor/core/extrinsics/async_weights.py
+++ b/bittensor/core/extrinsics/async_weights.py
@@ -125,7 +125,7 @@ async def set_weights_extrinsic(
)
logging.info(
- ":satellite: Setting weights on {subtensor.network} ..."
+ ":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
)
try:
success, error_message = await _do_set_weights(
@@ -144,14 +144,14 @@ async def set_weights_extrinsic(
if success is True:
message = "Successfully set weights and Finalized."
- logging.success(f":white_heavy_check_mark: {message}")
+ logging.success(f":white_heavy_check_mark: [green]{message}[/green]")
return True, message
else:
- logging.error(f"Failed set weights. Error: {error_message}")
+ logging.error(f"[red]Failed[/red] set weights. Error: {error_message}")
return False, error_message
except Exception as error:
- logging.error(f":cross_mark: Failed set weights. Error: {error}")
+ logging.error(f":cross_mark: [red]Failed[/red] set weights. Error: {error}")
return False, str(error)
diff --git a/bittensor/core/extrinsics/registration.py b/bittensor/core/extrinsics/registration.py
index 57bf9e7a56..e9836938d8 100644
--- a/bittensor/core/extrinsics/registration.py
+++ b/bittensor/core/extrinsics/registration.py
@@ -1,19 +1,10 @@
-# The MIT License (MIT)
-# Copyright © 2024 Opentensor Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-# the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
+"""
+This module provides functionalities for registering a wallet with the subtensor network using Proof-of-Work (PoW).
+
+Extrinsics:
+- register_extrinsic: Registers the wallet to the subnet.
+- burned_register_extrinsic: Registers the wallet to chain by recycling TAO.
+"""
import time
from typing import Union, Optional, TYPE_CHECKING
@@ -22,17 +13,19 @@
from bittensor.utils import format_error_message, unlock_key
from bittensor.utils.btlogging import logging
from bittensor.utils.networking import ensure_connected
-from bittensor.utils.registration import (
- POWSolution,
- create_pow,
- torch,
- log_no_torch_error,
-)
-
-# For annotation purposes
+from bittensor.utils.registration import create_pow, torch, log_no_torch_error
+from bittensor.core.extrinsics.utils import submit_extrinsic
+
+# For annotation and lazy import purposes
if TYPE_CHECKING:
- from bittensor.core.subtensor import Subtensor
+ import torch
from bittensor_wallet import Wallet
+ from bittensor.core.subtensor import Subtensor
+ from bittensor.utils.registration import POWSolution
+else:
+ from bittensor.utils.registration.pow import LazyLoadedTorch
+
+ torch = LazyLoadedTorch()
@ensure_connected
@@ -47,6 +40,7 @@ def _do_pow_register(
"""Sends a (POW) register extrinsic to the chain.
Args:
+ self (bittensor.core.subtensor.Subtensor): The subtensor to send the extrinsic to.
netuid (int): The subnet to register on.
wallet (bittensor.wallet): The wallet to register.
pow_result (POWSolution): The PoW result to register.
@@ -71,8 +65,9 @@ def _do_pow_register(
},
)
extrinsic = self.substrate.create_signed_extrinsic(call=call, keypair=wallet.hotkey)
- response = self.substrate.submit_extrinsic(
- extrinsic,
+ response = submit_extrinsic(
+ substrate=self.substrate,
+ extrinsic=extrinsic,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
)
@@ -111,7 +106,7 @@ def register_extrinsic(
Args:
subtensor (bittensor.core.subtensor.Subtensor): Subtensor interface.
- wallet (bittensor.wallet): Bittensor wallet object.
+ wallet (bittensor_wallet.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.
@@ -130,24 +125,25 @@ def register_extrinsic(
"""
if not subtensor.subnet_exists(netuid):
logging.error(
- f":cross_mark: Failed: Subnet {netuid} does not exist."
+ f":cross_mark: [red]Failed: [/red] Subnet [blue]{netuid}[/blue] does not exist."
)
return False
logging.info(
- f":satellite: Checking Account on subnet {netuid}..."
+ f":satellite: [magenta]Checking Account on subnet[/magenta] [blue]{netuid}[/blue][magenta]...[/magenta]"
)
neuron = subtensor.get_neuron_for_pubkey_and_subnet(
wallet.hotkey.ss58_address, netuid=netuid
)
+
if not neuron.is_null:
logging.debug(
- f"Wallet {wallet} is already registered on {neuron.netuid} with {neuron.uid}."
+ f"Wallet [green]{wallet}[/green] is already registered on [blue]{neuron.netuid}[/blue] with [blue]{neuron.uid}[/blue]."
)
return True
logging.debug(
- f"Registration hotkey: {wallet.hotkey.ss58_address}, Public coldkey: {wallet.coldkey.ss58_address} in the network: {subtensor.network}."
+ f"Registration hotkey: [blue]{wallet.hotkey.ss58_address}[/blue], [green]Public[/green] coldkey: [blue]{wallet.coldkey.ss58_address}[/blue] in the network: [blue]{subtensor.network}[/blue]."
)
if not torch:
@@ -158,13 +154,13 @@ def register_extrinsic(
attempts = 1
while True:
logging.info(
- f":satellite: Registering... ({attempts}/{max_allowed_attempts})"
+ f":satellite: [magenta]Registering...[/magenta] [blue]({attempts}/{max_allowed_attempts})[/blue]"
)
# Solve latest POW.
if cuda:
if not torch.cuda.is_available():
return False
- pow_result: Optional[POWSolution] = create_pow(
+ pow_result: Optional["POWSolution"] = create_pow(
subtensor,
wallet,
netuid,
@@ -177,7 +173,7 @@ def register_extrinsic(
log_verbose=log_verbose,
)
else:
- pow_result: Optional[POWSolution] = create_pow(
+ pow_result: Optional["POWSolution"] = create_pow(
subtensor,
wallet,
netuid,
@@ -196,13 +192,13 @@ def register_extrinsic(
)
if is_registered:
logging.info(
- f":white_heavy_check_mark: Already registered on netuid: {netuid}."
+ f":white_heavy_check_mark: [green]Already registered on netuid:[/green] [blue]{netuid}[/blue]."
)
return True
# pow successful, proceed to submit pow to chain for registration
else:
- logging.info(":satellite: Submitting POW...")
+ logging.info(":satellite: [magenta]Submitting POW...[/magenta]")
# check if pow result is still valid
while not pow_result.is_stale(subtensor=subtensor):
result: tuple[bool, Optional[str]] = _do_pow_register(
@@ -220,34 +216,35 @@ def register_extrinsic(
# https://github.com/opentensor/subtensor/blob/development/pallets/subtensor/src/errors.rs
if "HotKeyAlreadyRegisteredInSubNet" in err_msg:
logging.info(
- f":white_heavy_check_mark: Already Registered on subnet {netuid}."
+ f":white_heavy_check_mark: [green]Already Registered on subnet [/green][blue]{netuid}[/blue]."
)
return True
- logging.error(f":cross_mark: Failed: {err_msg}")
+ logging.error(f":cross_mark: [red]Failed:[/red] {err_msg}")
time.sleep(0.5)
# Successful registration, final check for neuron and pubkey
else:
- logging.info(":satellite: Checking Balance...")
+ logging.info(":satellite: [magenta]Checking Balance...[/magenta]")
is_registered = subtensor.is_hotkey_registered(
hotkey_ss58=wallet.hotkey.ss58_address,
netuid=netuid,
)
if is_registered:
logging.info(
- ":white_heavy_check_mark: Registered"
+ ":white_heavy_check_mark: [green]Registered[/green]"
)
return True
else:
# neuron not found, try again
logging.error(
- ":cross_mark: Unknown error. Neuron not found."
+ ":cross_mark: [red]Unknown error. Neuron not found.[/red]"
)
- continue
+ # keep commented due to this line brings loop to infinitive one
+ # continue
else:
# Exited loop because pow is no longer valid.
- logging.error("POW is stale.")
+ logging.error("[red]POW is stale.[/red]")
# Try again.
continue
@@ -255,11 +252,11 @@ def register_extrinsic(
# Failed registration, retry pow
attempts += 1
logging.info(
- f":satellite: Failed registration, retrying pow ... ({attempts}/{max_allowed_attempts})"
+ f":satellite: [magenta]Failed registration, retrying pow ...[/magenta] [blue]({attempts}/{max_allowed_attempts})[/blue]"
)
else:
# Failed to register after max attempts.
- logging.error("No more attempts.")
+ logging.error("[red]No more attempts.[/red]")
return False
@@ -274,8 +271,7 @@ def _do_burned_register(
"""
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. It
- retries the call up to three times with exponential backoff in case of failures.
+ This method sends a registration transaction to the Subtensor blockchain using the burned register mechanism.
Args:
self (bittensor.core.subtensor.Subtensor): Subtensor instance.
@@ -300,7 +296,8 @@ def _do_burned_register(
extrinsic = self.substrate.create_signed_extrinsic(
call=call, keypair=wallet.coldkey
)
- response = self.substrate.submit_extrinsic(
+ response = submit_extrinsic(
+ self.substrate,
extrinsic,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
@@ -342,7 +339,7 @@ def burned_register_extrinsic(
"""
if not subtensor.subnet_exists(netuid):
logging.error(
- f":cross_mark: Failed error: subnet {netuid} does not exist."
+ f":cross_mark: [red]Failed error:[/red] subnet [blue]{netuid}[/blue] does not exist."
)
return False
@@ -351,7 +348,7 @@ def burned_register_extrinsic(
return False
logging.info(
- f":satellite: Checking Account on subnet {netuid} ..."
+ f":satellite: [magenta]Checking Account on subnet[/magenta] [blue]{netuid}[/blue][magenta] ...[/magenta]"
)
neuron = subtensor.get_neuron_for_pubkey_and_subnet(
wallet.hotkey.ss58_address, netuid=netuid
@@ -360,14 +357,14 @@ def burned_register_extrinsic(
old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
if not neuron.is_null:
- logging.info(":white_heavy_check_mark: Already Registered")
- logging.info(f"\t\tuid: {neuron.uid}")
- logging.info(f"\t\tnetuid: {neuron.netuid}")
- logging.info(f"\t\thotkey: {neuron.hotkey}")
- logging.info(f"\t\tcoldkey: {neuron.coldkey}")
+ 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: Recycling TAO for Registration...")
+ logging.info(":satellite: [magenta]Recycling TAO for Registration...[/magenta]")
recycle_amount = subtensor.recycle(netuid=netuid)
logging.info(f"Recycling {recycle_amount} to register on subnet:{netuid}")
@@ -381,25 +378,25 @@ def burned_register_extrinsic(
)
if not success:
- logging.error(f":cross_mark: Failed error: {err_msg}")
+ logging.error(f":cross_mark: [red]Failed error:[/red] {err_msg}")
time.sleep(0.5)
return False
# Successful registration, final check for neuron and pubkey
else:
- logging.info(":satellite: Checking Balance...")
+ logging.info(":satellite: [magenta]Checking Balance...[/magenta]")
block = subtensor.get_current_block()
new_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address, block=block)
logging.info(
- f"Balance: {old_balance} :arrow_right: {new_balance}"
+ f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
)
is_registered = subtensor.is_hotkey_registered(
netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
)
if is_registered:
- logging.info(":white_heavy_check_mark: Registered")
+ logging.info(":white_heavy_check_mark: [green]Registered[/green]")
return True
else:
# neuron not found, try again
- logging.error(":cross_mark: Unknown error. Neuron not found.")
+ logging.error(":cross_mark: [red]Unknown error. Neuron not found.[/red]")
return False
diff --git a/bittensor/core/extrinsics/root.py b/bittensor/core/extrinsics/root.py
index fc3d1852a1..e4fec236fc 100644
--- a/bittensor/core/extrinsics/root.py
+++ b/bittensor/core/extrinsics/root.py
@@ -5,6 +5,7 @@
from numpy.typing import NDArray
from bittensor.core.settings import version_as_int
+from bittensor.core.extrinsics.utils import submit_extrinsic
from bittensor.utils import format_error_message, weight_utils, unlock_key
from bittensor.utils.btlogging import logging
from bittensor.utils.networking import ensure_connected
@@ -31,7 +32,8 @@ def _do_root_register(
extrinsic = self.substrate.create_signed_extrinsic(
call=call, keypair=wallet.coldkey
)
- response = self.substrate.submit_extrinsic(
+ response = submit_extrinsic(
+ self.substrate,
extrinsic,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
@@ -79,19 +81,20 @@ def root_register_extrinsic(
)
if is_registered:
logging.info(
- ":white_heavy_check_mark: Already registered on root network."
+ ":white_heavy_check_mark: [green]Already registered on root network.[/green]"
)
return True
- logging.info(":satellite: Registering to root network...")
+ logging.info(":satellite: [magenta]Registering to root network...[/magenta]")
success, err_msg = _do_root_register(
+ self=subtensor,
wallet=wallet,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
)
if not success:
- logging.error(f":cross_mark: Failed: {err_msg}")
+ logging.error(f":cross_mark: [red]Failed[/red]: {err_msg}")
time.sleep(0.5)
# Successful registration, final check for neuron and pubkey
@@ -100,11 +103,11 @@ def root_register_extrinsic(
netuid=0, hotkey_ss58=wallet.hotkey.ss58_address
)
if is_registered:
- logging.success(":white_heavy_check_mark: Registered")
+ logging.success(":white_heavy_check_mark: [green]Registered[/green]")
return True
else:
# neuron not found, try again
- logging.error(":cross_mark: Unknown error. Neuron not found.")
+ logging.error(":cross_mark: [red]Unknown error. Neuron not found.[/red]")
@ensure_connected
@@ -117,6 +120,7 @@ def _do_set_root_weights(
version_key: int = version_as_int,
wait_for_inclusion: bool = False,
wait_for_finalization: bool = False,
+ period: int = 5,
) -> tuple[bool, Optional[str]]:
"""
Internal method to send a transaction to the Bittensor blockchain, setting weights for specified neurons on root. This method constructs and submits the transaction, handling retries and blockchain communication.
@@ -152,9 +156,10 @@ def _do_set_root_weights(
extrinsic = self.substrate.create_signed_extrinsic(
call=call,
keypair=wallet.coldkey,
- era={"period": 5},
+ era={"period": period},
)
- response = self.substrate.submit_extrinsic(
+ response = submit_extrinsic(
+ self.substrate,
extrinsic,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
@@ -224,17 +229,18 @@ def set_root_weights_extrinsic(
x=weights, limit=max_weight_limit
)
logging.info(
- f"Raw Weights -> Normalized weights: {weights} -> {formatted_weights}"
+ f"Raw Weights -> Normalized weights: [blue]{weights}[/blue] -> [green]{formatted_weights}[/green]"
)
logging.info(
- f":satellite: Setting root weights on {subtensor.network} ..."
+ f":satellite: [magenta]Setting root weights on[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
)
try:
weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit(
netuids, weights
)
success, error_message = _do_set_root_weights(
+ self=subtensor,
wallet=wallet,
netuid=0,
uids=weight_uids,
@@ -248,15 +254,15 @@ def set_root_weights_extrinsic(
return True
if success is True:
- logging.info(":white_heavy_check_mark: Finalized")
+ logging.info(":white_heavy_check_mark: [green]Finalized[/green]")
logging.success(f"Set weights {str(success)}")
return True
else:
logging.error(
- f":cross_mark: Failed set weights. {str(error_message)}"
+ f":cross_mark: [red]Failed [/red] set weights. {str(error_message)}"
)
return False
except Exception as e:
- logging.error(f":cross_mark: Failed set weights. {str(e)}")
+ logging.error(f":cross_mark: [red]Failed [/red] set weights. {str(e)}")
return False
diff --git a/bittensor/core/extrinsics/serving.py b/bittensor/core/extrinsics/serving.py
index 02630ff91c..1c26b87e76 100644
--- a/bittensor/core/extrinsics/serving.py
+++ b/bittensor/core/extrinsics/serving.py
@@ -20,7 +20,12 @@
from bittensor.core.errors import MetadataError
from bittensor.core.extrinsics.utils import submit_extrinsic
from bittensor.core.settings import version_as_int
-from bittensor.utils import format_error_message, networking as net, unlock_key
+from bittensor.utils import (
+ format_error_message,
+ networking as net,
+ unlock_key,
+ Certificate,
+)
from bittensor.utils.btlogging import logging
from bittensor.utils.networking import ensure_connected
@@ -57,9 +62,15 @@ def do_serve_axon(
This function is crucial for initializing and announcing a neuron's ``Axon`` service on the network, enhancing the decentralized computation capabilities of Bittensor.
"""
+ if call_params["certificate"] is None:
+ del call_params["certificate"]
+ call_function = "serve_axon"
+ else:
+ call_function = "serve_axon_tls"
+
call = self.substrate.compose_call(
call_module="SubtensorModule",
- call_function="serve_axon",
+ call_function=call_function,
call_params=call_params,
)
extrinsic = self.substrate.create_signed_extrinsic(call=call, keypair=wallet.hotkey)
@@ -90,6 +101,7 @@ def serve_extrinsic(
placeholder2: int = 0,
wait_for_inclusion: bool = False,
wait_for_finalization=True,
+ certificate: Optional[Certificate] = None,
) -> bool:
"""Subscribes a Bittensor endpoint to the subtensor chain.
@@ -124,6 +136,7 @@ def serve_extrinsic(
"protocol": protocol,
"placeholder1": placeholder1,
"placeholder2": placeholder2,
+ "certificate": certificate,
}
logging.debug("Checking axon ...")
neuron = subtensor.get_neuron_for_pubkey_and_subnet(
@@ -182,6 +195,7 @@ def serve_axon_extrinsic(
axon: "Axon",
wait_for_inclusion: bool = False,
wait_for_finalization: bool = True,
+ certificate: Optional[Certificate] = None,
) -> bool:
"""Serves the axon to the network.
@@ -205,7 +219,7 @@ def serve_axon_extrinsic(
try:
external_ip = net.get_external_ip()
logging.success(
- f":white_heavy_check_mark: Found external ip: {external_ip}"
+ f":white_heavy_check_mark: [green]Found external ip:[/green] [blue]{external_ip}[/blue]"
)
except Exception as e:
raise RuntimeError(
@@ -224,6 +238,7 @@ def serve_axon_extrinsic(
protocol=4,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
+ certificate=certificate,
)
return serve_success
@@ -273,7 +288,8 @@ def publish_metadata(
)
extrinsic = substrate.create_signed_extrinsic(call=call, keypair=wallet.hotkey)
- response = substrate.submit_extrinsic(
+ response = submit_extrinsic(
+ substrate,
extrinsic,
wait_for_inclusion=wait_for_inclusion,
wait_for_finalization=wait_for_finalization,
diff --git a/bittensor/core/extrinsics/set_weights.py b/bittensor/core/extrinsics/set_weights.py
index e9a7d88d35..880480e998 100644
--- a/bittensor/core/extrinsics/set_weights.py
+++ b/bittensor/core/extrinsics/set_weights.py
@@ -145,7 +145,7 @@ def set_weights_extrinsic(
)
logging.info(
- f":satellite: Setting weights on {subtensor.network} ..."
+ f":satellite: [magenta]Setting weights on [/magenta][blue]{subtensor.network}[blue] [magenta]...[/magenta]"
)
logging.debug(f"Weights: {[float(v / 65535) for v in weight_vals]}")
@@ -165,13 +165,13 @@ def set_weights_extrinsic(
return True, "Not waiting for finalization or inclusion."
if success is True:
- logging.success(f"Finalized! Set weights: {str(success)}")
+ logging.success(f"[green]Finalized![/green] Set weights: {str(success)}")
return True, "Successfully set weights and Finalized."
else:
logging.error(error_message)
return False, error_message
except Exception as e:
- logging.error(f":cross_mark: Failed.: Error: {e}")
+ logging.error(f":cross_mark: [red]Failed.[/red]: Error: {e}")
logging.debug(str(e))
return False, str(e)
diff --git a/bittensor/core/extrinsics/staking.py b/bittensor/core/extrinsics/staking.py
new file mode 100644
index 0000000000..769043c857
--- /dev/null
+++ b/bittensor/core/extrinsics/staking.py
@@ -0,0 +1,479 @@
+from time import sleep
+from typing import Union, Optional, TYPE_CHECKING
+
+from bittensor.core.errors import NotDelegateError, StakeError, NotRegisteredError
+from bittensor.utils import format_error_message, unlock_key
+from bittensor.utils.balance import Balance
+from bittensor.utils.btlogging import logging
+from bittensor.utils.networking import ensure_connected
+
+if TYPE_CHECKING:
+ from bittensor_wallet import Wallet
+ from bittensor.core.subtensor import Subtensor
+
+
+@ensure_connected
+def _do_stake(
+ self: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: str,
+ amount: "Balance",
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Sends a stake extrinsic to the chain.
+
+ Args:
+ self (subtensor): Subtensor instance.
+ wallet (bittensor_wallet.Wallet): Wallet object that can sign the extrinsic.
+ hotkey_ss58 (str): Hotkey ``ss58`` address to stake to.
+ amount (bittensor.utils.balance.Balance): Amount to stake.
+ wait_for_inclusion (bool): If ``true``, waits for inclusion before returning.
+ wait_for_finalization (bool): If ``true``, waits for finalization before returning.
+
+ Returns:
+ success (bool): ``True`` if the extrinsic was successful.
+
+ Raises:
+ bittensor.core.errors.StakeError: If the extrinsic failed.
+ """
+
+ call = self.substrate.compose_call(
+ call_module="SubtensorModule",
+ call_function="add_stake",
+ call_params={"hotkey": hotkey_ss58, "amount_staked": amount.rao},
+ )
+ extrinsic = self.substrate.create_signed_extrinsic(
+ call=call, keypair=wallet.coldkey
+ )
+ response = self.substrate.submit_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
+
+ response.process_events()
+ if response.is_success:
+ return True
+ else:
+ raise StakeError(
+ format_error_message(response.error_message, substrate=self.substrate)
+ )
+
+
+def _check_threshold_amount(
+ subtensor: "Subtensor", stake_balance: Balance
+) -> tuple[bool, Balance]:
+ """
+ Checks if the new stake balance will be above the minimum required stake threshold.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ stake_balance (Balance): the balance to check for threshold limits.
+
+ Returns:
+ success, threshold (bool, Balance): ``true`` if the staking balance is above the threshold, or ``false`` if the staking balance is below the threshold. The threshold balance required to stake.
+ """
+ min_req_stake: Balance = subtensor.get_minimum_required_stake()
+ if min_req_stake > stake_balance:
+ return False, min_req_stake
+ else:
+ return True, min_req_stake
+
+
+def __do_add_stake_single(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: str,
+ amount: "Balance",
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """
+ Executes a stake call to the chain using the wallet and the amount specified.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): Bittensor wallet object.
+ hotkey_ss58 (str): Hotkey to stake to.
+ amount (bittensor.utils.balance.Balance): Amount to stake as Bittensor balance object.
+ 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``.
+
+ Raises:
+ bittensor.core.errors.StakeError: If the extrinsic fails to be finalized or included in the block.
+ bittensor.core.errors.NotDelegateError: If the hotkey is not a delegate.
+ bittensor.core.errors.NotRegisteredError: If the hotkey is not registered in any subnets.
+
+ """
+ # Decrypt keys,
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ hotkey_owner = subtensor.get_hotkey_owner(hotkey_ss58)
+ own_hotkey = wallet.coldkeypub.ss58_address == hotkey_owner
+ if not own_hotkey:
+ # We are delegating. Verify that the hotkey is a delegate.
+ if not subtensor.is_hotkey_delegate(hotkey_ss58=hotkey_ss58):
+ raise NotDelegateError("Hotkey: {} is not a delegate.".format(hotkey_ss58))
+
+ success = _do_stake(
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=amount,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+ return success
+
+
+def add_stake_extrinsic(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: Optional[str] = None,
+ amount: Optional[Union[Balance, float]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Adds the specified amount of stake to passed hotkey ``uid``.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ wallet (Wallet): Bittensor wallet object.
+ hotkey_ss58 (Optional[str]): The ``ss58`` address of the hotkey account to stake to defaults to the wallet's hotkey.
+ amount (Union[Balance, float]): Amount to stake as Bittensor balance, or ``float`` interpreted as Tao.
+ 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``.
+
+ Raises:
+ bittensor.core.errors.NotRegisteredError: If the wallet is not registered on the chain.
+ bittensor.core.errors.NotDelegateError: If the hotkey is not a delegate on the chain.
+ """
+ # Decrypt keys,
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ # Default to wallet's own hotkey if the value is not passed.
+ if hotkey_ss58 is None:
+ hotkey_ss58 = wallet.hotkey.ss58_address
+
+ # Flag to indicate if we are using the wallet's own hotkey.
+ own_hotkey: bool
+
+ logging.info(
+ f":satellite: [magenta]Syncing with chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+ # Get hotkey owner
+ hotkey_owner = subtensor.get_hotkey_owner(hotkey_ss58)
+ own_hotkey = wallet.coldkeypub.ss58_address == hotkey_owner
+ if not own_hotkey:
+ # This is not the wallet's own hotkey so we are delegating.
+ if not subtensor.is_hotkey_delegate(hotkey_ss58):
+ raise NotDelegateError("Hotkey: {} is not a delegate.".format(hotkey_ss58))
+
+ # Get current stake
+ old_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58
+ )
+
+ # Grab the existential deposit.
+ existential_deposit = subtensor.get_existential_deposit()
+
+ # Convert to bittensor.Balance
+ if amount is None:
+ # Stake it all.
+ staking_balance = Balance.from_tao(old_balance.tao)
+ elif not isinstance(amount, Balance):
+ staking_balance = Balance.from_tao(amount)
+ else:
+ staking_balance = amount
+
+ # Leave existential balance to keep key alive.
+ if staking_balance > old_balance - existential_deposit:
+ # If we are staking all, we need to leave at least the existential deposit.
+ staking_balance = old_balance - existential_deposit
+ else:
+ staking_balance = staking_balance
+
+ # Check enough to stake.
+ if staking_balance > old_balance:
+ logging.error(":cross_mark: [red]Not enough stake:[/red]")
+ logging.error(f"\t\tbalance:{old_balance}")
+ logging.error(f"\t\tamount: {staking_balance}")
+ logging.error(f"\t\twallet: {wallet.name}")
+ return False
+
+ # If nominating, we need to check if the new stake balance will be above the minimum required stake threshold.
+ if not own_hotkey:
+ new_stake_balance = old_stake + staking_balance
+ is_above_threshold, threshold = _check_threshold_amount(
+ subtensor, new_stake_balance
+ )
+ if not is_above_threshold:
+ logging.error(
+ f":cross_mark: [red]New stake balance of {new_stake_balance} is below the minimum required nomination stake threshold {threshold}.[/red]"
+ )
+ return False
+
+ try:
+ logging.info(
+ f":satellite: [magenta]Staking to:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ staking_response: bool = __do_add_stake_single(
+ subtensor=subtensor,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=staking_balance,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ if staking_response is True: # If we successfully staked.
+ # We only wait here if we expect finalization.
+ if not wait_for_finalization and not wait_for_inclusion:
+ return True
+
+ logging.success(":white_heavy_check_mark: [green]Finalized[/green]")
+
+ logging.info(
+ f":satellite: [magenta]Checking Balance on:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ new_balance = subtensor.get_balance(address=wallet.coldkeypub.ss58_address)
+ block = subtensor.get_current_block()
+ new_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address,
+ hotkey_ss58=hotkey_ss58,
+ block=block,
+ ) # Get current stake
+
+ logging.info("Balance:")
+ logging.info(
+ f"[blue]{old_balance}[/blue] :arrow_right: {new_balance}[/green]"
+ )
+ logging.info("Stake:")
+ logging.info(
+ f"[blue]{old_stake}[/blue] :arrow_right: [green]{new_stake}[/green]"
+ )
+ return True
+ else:
+ logging.error(":cross_mark: [red]Failed[/red]: Error unknown.")
+ return False
+
+ except NotRegisteredError:
+ logging.error(
+ ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format(
+ wallet.hotkey_str
+ )
+ )
+ return False
+ except StakeError as e:
+ logging.error(f":cross_mark: [red]Stake Error: {e}[/red]")
+ return False
+
+
+def add_stake_multiple_extrinsic(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58s: list[str],
+ amounts: Optional[list[Union[Balance, float]]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Adds stake to each ``hotkey_ss58`` in the list, using each amount, from a common coldkey.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ wallet (bittensor_wallet.Wallet): Bittensor wallet object for the coldkey.
+ hotkey_ss58s (List[str]): List of hotkeys to stake to.
+ amounts (List[Union[Balance, float]]): List of amounts to stake. If ``None``, stake all to the first hotkey.
+ 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 included in the block. Flag is ``true`` if any wallet was staked. If we did not wait for finalization / inclusion, the response is ``true``.
+ """
+ if not isinstance(hotkey_ss58s, list) or not all(
+ isinstance(hotkey_ss58, str) for hotkey_ss58 in hotkey_ss58s
+ ):
+ raise TypeError("hotkey_ss58s must be a list of str")
+
+ if len(hotkey_ss58s) == 0:
+ return True
+
+ if amounts is not None and len(amounts) != len(hotkey_ss58s):
+ raise ValueError("amounts must be a list of the same length as hotkey_ss58s")
+
+ if amounts is not None and not all(
+ isinstance(amount, (Balance, float)) for amount in amounts
+ ):
+ raise TypeError(
+ "amounts must be a [list of bittensor.Balance or float] or None"
+ )
+
+ if amounts is None:
+ amounts = [None] * len(hotkey_ss58s)
+ else:
+ # Convert to Balance
+ amounts = [
+ Balance.from_tao(amount) if isinstance(amount, float) else amount
+ for amount in amounts
+ ]
+
+ if sum(amount.tao for amount in amounts) == 0:
+ # Staking 0 tao
+ return True
+
+ # Decrypt keys,
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ old_stakes = []
+
+ logging.info(
+ f":satellite: [magenta]Syncing with chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+
+ # Get the old stakes.
+ for hotkey_ss58 in hotkey_ss58s:
+ old_stakes.append(
+ subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58
+ )
+ )
+
+ # Remove existential balance to keep key alive.
+ # Keys must maintain a balance of at least 1000 rao to stay alive.
+ total_staking_rao = sum(
+ [amount.rao if amount is not None else 0 for amount in amounts]
+ )
+ if total_staking_rao == 0:
+ # Staking all to the first wallet.
+ if old_balance.rao > 1000:
+ old_balance -= Balance.from_rao(1000)
+
+ elif total_staking_rao < 1000:
+ # Staking less than 1000 rao to the wallets.
+ pass
+ else:
+ # Staking more than 1000 rao to the wallets.
+ # Reduce the amount to stake to each wallet to keep the balance above 1000 rao.
+ percent_reduction = 1 - (1000 / total_staking_rao)
+ amounts = [
+ Balance.from_tao(amount.tao * percent_reduction) for amount in amounts
+ ]
+
+ successful_stakes = 0
+ for idx, (hotkey_ss58, amount, old_stake) in enumerate(
+ zip(hotkey_ss58s, amounts, old_stakes)
+ ):
+ staking_all = False
+ # Convert to bittensor.Balance
+ if amount is None:
+ # Stake it all.
+ staking_balance = Balance.from_tao(old_balance.tao)
+ staking_all = True
+ else:
+ # Amounts are cast to balance earlier in the function
+ assert isinstance(amount, Balance)
+ staking_balance = amount
+
+ # Check enough to stake
+ if staking_balance > old_balance:
+ logging.error(
+ f":cross_mark: [red]Not enough balance[/red]: [green]{old_balance}[/green] to stake: [blue]{staking_balance}[/blue] from wallet: [white]{wallet.name}[/white]"
+ )
+ continue
+
+ try:
+ staking_response: bool = __do_add_stake_single(
+ subtensor=subtensor,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=staking_balance,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ # If we successfully staked.
+ if staking_response:
+ # We only wait here if we expect finalization.
+
+ if idx < len(hotkey_ss58s) - 1:
+ # Wait for tx rate limit.
+ tx_rate_limit_blocks = subtensor.tx_rate_limit()
+ if tx_rate_limit_blocks > 0:
+ logging.error(
+ f":hourglass: [yellow]Waiting for tx rate limit: [white]{tx_rate_limit_blocks}[/white] blocks[/yellow]"
+ )
+ sleep(tx_rate_limit_blocks * 12) # 12 seconds per block
+
+ if not wait_for_finalization and not wait_for_inclusion:
+ old_balance -= staking_balance
+ successful_stakes += 1
+ if staking_all:
+ # If staked all, no need to continue
+ break
+
+ continue
+
+ logging.success(":white_heavy_check_mark: [green]Finalized[/green]")
+
+ block = subtensor.get_current_block()
+ new_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address,
+ hotkey_ss58=hotkey_ss58,
+ block=block,
+ )
+ new_balance = subtensor.get_balance(
+ wallet.coldkeypub.ss58_address, block=block
+ )
+ logging.info(
+ "Stake ({}): [blue]{}[/blue] :arrow_right: [green]{}[/green]".format(
+ hotkey_ss58, old_stake, new_stake
+ )
+ )
+ old_balance = new_balance
+ successful_stakes += 1
+ if staking_all:
+ # If staked all, no need to continue
+ break
+
+ else:
+ logging.error(":cross_mark: [red]Failed[/red]: Error unknown.")
+ continue
+
+ except NotRegisteredError:
+ logging.error(
+ ":cross_mark: [red]Hotkey: {} is not registered.[/red]".format(
+ hotkey_ss58
+ )
+ )
+ continue
+ except StakeError as e:
+ logging.error(":cross_mark: [red]Stake Error: {}[/red]".format(e))
+ continue
+
+ if successful_stakes != 0:
+ logging.info(
+ f":satellite: [magenta]Checking Balance on:[/magenta] ([blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ new_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+ logging.info(
+ f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
+ )
+ return True
+
+ return False
diff --git a/bittensor/core/extrinsics/transfer.py b/bittensor/core/extrinsics/transfer.py
index abadf8eee0..c3b919f381 100644
--- a/bittensor/core/extrinsics/transfer.py
+++ b/bittensor/core/extrinsics/transfer.py
@@ -114,7 +114,7 @@ def transfer_extrinsic(
"""
# Validate destination address.
if not is_valid_bittensor_address_or_public_key(dest):
- logging.error(f"Invalid destination address: {dest}")
+ logging.error(f"[red]Invalid destination address: {dest}[/red]")
return False
if isinstance(dest, bytes):
@@ -132,12 +132,12 @@ def transfer_extrinsic(
transfer_balance = amount
# Check balance.
- logging.info(":satellite: Checking Balance...")
+ logging.info(":satellite: [magenta]Checking Balance...[/magenta]")
account_balance = subtensor.get_balance(wallet.coldkey.ss58_address)
# check existential deposit.
existential_deposit = subtensor.get_existential_deposit()
- logging.info(":satellite: Transferring...")
+ logging.info(":satellite: [magenta]Transferring...[/magenta]")
fee = subtensor.get_transfer_fee(
wallet=wallet, dest=dest, value=transfer_balance.rao
)
@@ -148,17 +148,17 @@ def transfer_extrinsic(
# Check if we have enough balance.
if account_balance < (transfer_balance + fee + existential_deposit):
- logging.error(":cross_mark: Not enough balance:")
- logging.info(f"\t\tBalance: \t{account_balance}")
- logging.info(f"\t\tAmount: \t{transfer_balance}")
- logging.info(f"\t\tFor fee: \t{fee}")
+ logging.error(":cross_mark: [red]Not enough balance[/red]:")
+ logging.info(f"\t\tBalance: \t[blue]{account_balance}[/blue]")
+ logging.info(f"\t\tAmount: \t[blue]{transfer_balance}[/blue]")
+ logging.info(f"\t\tFor fee: \t[blue]{fee}[/blue]")
return False
- logging.info(":satellite: Transferring...")
- logging.info(f"\tAmount: {transfer_balance}")
- logging.info(f"\tfrom: {wallet.name}:{wallet.coldkey.ss58_address}")
- logging.info(f"\tTo: {dest}")
- logging.info(f"\tFor fee: {fee}")
+ logging.info(":satellite: [magenta]Transferring...[/magenta]")
+ logging.info(f"\tAmount: [blue]{transfer_balance}[/blue]")
+ logging.info(f"\tfrom: [blue]{wallet.name}:{wallet.coldkey.ss58_address}[/blue]")
+ logging.info(f"\tTo: [blue]{dest}[/blue]")
+ logging.info(f"\tFor fee: [blue]{fee}[/blue]")
success, block_hash, error_message = do_transfer(
self=subtensor,
@@ -170,29 +170,29 @@ def transfer_extrinsic(
)
if success:
- logging.success(":white_heavy_check_mark: Finalized")
- logging.info(f"Block Hash: {block_hash}")
+ logging.success(":white_heavy_check_mark: [green]Finalized[/green]")
+ logging.info(f"[green]Block Hash:[/green] [blue]{block_hash}[/blue]")
explorer_urls = get_explorer_url_for_network(
subtensor.network, block_hash, NETWORK_EXPLORER_MAP
)
if explorer_urls != {} and explorer_urls:
logging.info(
- f"Opentensor Explorer Link: {explorer_urls.get('opentensor')}"
+ f"[green]Opentensor Explorer Link: {explorer_urls.get('opentensor')}[/green]"
)
logging.info(
- f"Taostats Explorer Link: {explorer_urls.get('taostats')}"
+ f"[green]Taostats Explorer Link: {explorer_urls.get('taostats')}[/green]"
)
else:
logging.error(
- f":cross_mark: Failed: {format_error_message(error_message, substrate=subtensor.substrate)}"
+ f":cross_mark: [red]Failed[/red]: {format_error_message(error_message, substrate=subtensor.substrate)}"
)
if success:
- logging.info(":satellite: Checking Balance...")
+ logging.info(":satellite: [magenta]Checking Balance...[/magenta]")
new_balance = subtensor.get_balance(wallet.coldkey.ss58_address)
logging.success(
- f"Balance: {account_balance} :arrow_right: {new_balance}"
+ f"Balance: [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
)
return True
diff --git a/bittensor/core/extrinsics/unstaking.py b/bittensor/core/extrinsics/unstaking.py
new file mode 100644
index 0000000000..5089410187
--- /dev/null
+++ b/bittensor/core/extrinsics/unstaking.py
@@ -0,0 +1,416 @@
+from time import sleep
+from typing import Union, Optional, TYPE_CHECKING
+
+from bittensor.core.errors import StakeError, NotRegisteredError
+from bittensor.utils import format_error_message, unlock_key
+from bittensor.utils.balance import Balance
+from bittensor.utils.btlogging import logging
+from bittensor.utils.networking import ensure_connected
+
+if TYPE_CHECKING:
+ from bittensor_wallet import Wallet
+ from bittensor.core.subtensor import Subtensor
+
+
+@ensure_connected
+def _do_unstake(
+ self: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: str,
+ amount: "Balance",
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Sends an unstake extrinsic to the chain.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): Wallet object that can sign the extrinsic.
+ hotkey_ss58 (str): Hotkey ``ss58`` address to unstake from.
+ amount (bittensor.utils.balance.Balance): Amount to unstake.
+ wait_for_inclusion (bool): If ``true``, waits for inclusion before returning.
+ wait_for_finalization (bool): If ``true``, waits for finalization before returning.
+
+ Returns:
+ success (bool): ``True`` if the extrinsic was successful.
+
+ Raises:
+ StakeError: If the extrinsic failed.
+ """
+
+ call = self.substrate.compose_call(
+ call_module="SubtensorModule",
+ call_function="remove_stake",
+ call_params={"hotkey": hotkey_ss58, "amount_unstaked": amount.rao},
+ )
+ extrinsic = self.substrate.create_signed_extrinsic(
+ call=call, keypair=wallet.coldkey
+ )
+ response = self.substrate.submit_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
+
+ response.process_events()
+ if response.is_success:
+ return True
+ else:
+ raise StakeError(
+ format_error_message(response.error_message, substrate=self.substrate)
+ )
+
+
+def _check_threshold_amount(subtensor: "Subtensor", stake_balance: "Balance") -> bool:
+ """
+ Checks if the remaining stake balance is above the minimum required stake threshold.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ stake_balance (bittensor.utils.balance.Balance): the balance to check for threshold limits.
+
+ Returns:
+ success (bool): ``true`` if the unstaking is above the threshold or 0, or ``false`` if the unstaking is below the threshold, but not 0.
+ """
+ min_req_stake: Balance = subtensor.get_minimum_required_stake()
+
+ if min_req_stake > stake_balance > 0:
+ logging.warning(
+ f":cross_mark: [yellow]Remaining stake balance of {stake_balance} less than minimum of {min_req_stake} TAO[/yellow]"
+ )
+ return False
+ else:
+ return True
+
+
+def __do_remove_stake_single(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: str,
+ amount: "Balance",
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """
+ Executes an unstake call to the chain using the wallet and the amount specified.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): Bittensor wallet object.
+ hotkey_ss58 (str): Hotkey address to unstake from.
+ amount (bittensor.utils.balance.Balance): Amount to unstake as Bittensor balance object.
+ 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``.
+
+ Raises:
+ bittensor.core.errors.StakeError: If the extrinsic fails to be finalized or included in the block.
+ bittensor.core.errors.NotRegisteredError: If the hotkey is not registered in any subnets.
+
+ """
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ success = _do_unstake(
+ self=subtensor,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=amount,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ return success
+
+
+def unstake_extrinsic(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58: Optional[str] = None,
+ amount: Optional[Union[Balance, float]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Removes stake into the wallet coldkey from the specified hotkey ``uid``.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ wallet (bittensor_wallet.Wallet): Bittensor wallet object.
+ hotkey_ss58 (Optional[str]): The ``ss58`` address of the hotkey to unstake from. By default, the wallet hotkey is used.
+ amount (Union[Balance, float]): Amount to stake as Bittensor balance, or ``float`` interpreted as Tao.
+ 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``.
+ """
+ # Decrypt keys,
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ if hotkey_ss58 is None:
+ hotkey_ss58 = wallet.hotkey.ss58_address # Default to wallet's own hotkey.
+
+ logging.info(
+ f":satellite: [magenta]Syncing with chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+ old_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58
+ )
+
+ hotkey_owner = subtensor.get_hotkey_owner(hotkey_ss58)
+ own_hotkey: bool = wallet.coldkeypub.ss58_address == hotkey_owner
+
+ # Convert to bittensor.Balance
+ if amount is None:
+ # Unstake it all.
+ unstaking_balance = old_stake
+ elif not isinstance(amount, Balance):
+ unstaking_balance = Balance.from_tao(amount)
+ else:
+ unstaking_balance = amount
+
+ # Check enough to unstake.
+ stake_on_uid = old_stake
+ if unstaking_balance > stake_on_uid:
+ logging.error(
+ f":cross_mark: [red]Not enough stake[/red]: [green]{stake_on_uid}[/green] to unstake: [blue]{unstaking_balance}[/blue] from hotkey: [yellow]{wallet.hotkey_str}[/yellow]"
+ )
+ return False
+
+ # If nomination stake, check threshold.
+ if not own_hotkey and not _check_threshold_amount(
+ subtensor=subtensor, stake_balance=(stake_on_uid - unstaking_balance)
+ ):
+ logging.warning(
+ ":warning: [yellow]This action will unstake the entire staked balance![/yellow]"
+ )
+ unstaking_balance = stake_on_uid
+
+ try:
+ logging.info(
+ f":satellite: [magenta]Unstaking from chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ staking_response: bool = __do_remove_stake_single(
+ subtensor=subtensor,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=unstaking_balance,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ if staking_response is True: # If we successfully unstaked.
+ # We only wait here if we expect finalization.
+ if not wait_for_finalization and not wait_for_inclusion:
+ return True
+
+ logging.success(":white_heavy_check_mark: [green]Finalized[/green]")
+
+ logging.info(
+ f":satellite: [magenta]Checking Balance on:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ new_balance = subtensor.get_balance(address=wallet.coldkeypub.ss58_address)
+ new_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58
+ ) # Get stake on hotkey.
+ logging.info(f"Balance:")
+ logging.info(
+ f"\t\t[blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
+ )
+ logging.info("Stake:")
+ logging.info(
+ f"\t\t[blue]{old_stake}[/blue] :arrow_right: [green]{new_stake}[/green]"
+ )
+ return True
+ else:
+ logging.error(":cross_mark: [red]Failed[/red]: Unknown Error.")
+ return False
+
+ except NotRegisteredError:
+ logging.error(
+ f":cross_mark: [red]Hotkey: {wallet.hotkey_str} is not registered.[/red]"
+ )
+ return False
+ except StakeError as e:
+ logging.error(":cross_mark: [red]Stake Error: {}[/red]".format(e))
+ return False
+
+
+def unstake_multiple_extrinsic(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ hotkey_ss58s: list[str],
+ amounts: Optional[list[Union[Balance, float]]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+) -> bool:
+ """Removes stake from each ``hotkey_ss58`` in the list, using each amount, to a common coldkey.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance.
+ wallet (bittensor_wallet.Wallet): The wallet with the coldkey to unstake to.
+ hotkey_ss58s (List[str]): List of hotkeys to unstake from.
+ amounts (List[Union[Balance, float]]): List of amounts to unstake. If ``None``, unstake all.
+ 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 included in the block. Flag is ``true`` if any wallet was unstaked. If we did not wait for finalization / inclusion, the response is ``true``.
+ """
+ if not isinstance(hotkey_ss58s, list) or not all(
+ isinstance(hotkey_ss58, str) for hotkey_ss58 in hotkey_ss58s
+ ):
+ raise TypeError("hotkey_ss58s must be a list of str")
+
+ if len(hotkey_ss58s) == 0:
+ return True
+
+ if amounts is not None and len(amounts) != len(hotkey_ss58s):
+ raise ValueError("amounts must be a list of the same length as hotkey_ss58s")
+
+ if amounts is not None and not all(
+ isinstance(amount, (Balance, float)) for amount in amounts
+ ):
+ raise TypeError(
+ "amounts must be a [list of bittensor.Balance or float] or None"
+ )
+
+ if amounts is None:
+ amounts = [None] * len(hotkey_ss58s)
+ else:
+ # Convert to Balance
+ amounts = [
+ Balance.from_tao(amount) if isinstance(amount, float) else amount
+ for amount in amounts
+ ]
+
+ if sum(amount.tao for amount in amounts) == 0:
+ # Staking 0 tao
+ return True
+
+ # Unlock coldkey.
+ if not (unlock := unlock_key(wallet)).success:
+ logging.error(unlock.message)
+ return False
+
+ old_stakes = []
+ own_hotkeys = []
+ logging.info(
+ f":satellite: [magenta]Syncing with chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ old_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+
+ for hotkey_ss58 in hotkey_ss58s:
+ old_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address, hotkey_ss58=hotkey_ss58
+ ) # Get stake on hotkey.
+ old_stakes.append(old_stake) # None if not registered.
+
+ hotkey_owner = subtensor.get_hotkey_owner(hotkey_ss58)
+ own_hotkeys.append(wallet.coldkeypub.ss58_address == hotkey_owner)
+
+ successful_unstakes = 0
+ for idx, (hotkey_ss58, amount, old_stake, own_hotkey) in enumerate(
+ zip(hotkey_ss58s, amounts, old_stakes, own_hotkeys)
+ ):
+ # Covert to bittensor.Balance
+ if amount is None:
+ # Unstake it all.
+ unstaking_balance = old_stake
+ else:
+ unstaking_balance = (
+ amount if isinstance(amount, Balance) else Balance.from_tao(amount)
+ )
+
+ # Check enough to unstake.
+ stake_on_uid = old_stake
+ if unstaking_balance > stake_on_uid:
+ logging.error(
+ f":cross_mark: [red]Not enough stake[/red]: [green]{stake_on_uid}[/green] to unstake: [blue]{unstaking_balance}[/blue] from hotkey: [blue]{wallet.hotkey_str}[/blue]."
+ )
+ continue
+
+ # If nomination stake, check threshold.
+ if not own_hotkey and not _check_threshold_amount(
+ subtensor=subtensor, stake_balance=(stake_on_uid - unstaking_balance)
+ ):
+ logging.warning(
+ f":warning: [yellow]This action will unstake the entire staked balance![/yellow]"
+ )
+ unstaking_balance = stake_on_uid
+
+ try:
+ logging.info(
+ f":satellite: [magenta]Unstaking from chain:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ staking_response: bool = __do_remove_stake_single(
+ subtensor=subtensor,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=unstaking_balance,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ if staking_response is True: # If we successfully unstaked.
+ # We only wait here if we expect finalization.
+
+ if idx < len(hotkey_ss58s) - 1:
+ # Wait for tx rate limit.
+ tx_rate_limit_blocks = subtensor.tx_rate_limit()
+ if tx_rate_limit_blocks > 0:
+ logging.info(
+ f":hourglass: [yellow]Waiting for tx rate limit: [white]{tx_rate_limit_blocks}[/white] blocks[/yellow]"
+ )
+ sleep(tx_rate_limit_blocks * 12) # 12 seconds per block
+
+ if not wait_for_finalization and not wait_for_inclusion:
+ successful_unstakes += 1
+ continue
+
+ logging.info(":white_heavy_check_mark: [green]Finalized[/green]")
+
+ logging.info(
+ f":satellite: [magenta]Checking Balance on:[/magenta] [blue]{subtensor.network}[/blue] [magenta]...[/magenta]..."
+ )
+ block = subtensor.get_current_block()
+ new_stake = subtensor.get_stake_for_coldkey_and_hotkey(
+ coldkey_ss58=wallet.coldkeypub.ss58_address,
+ hotkey_ss58=hotkey_ss58,
+ block=block,
+ )
+ logging.info(
+ f"Stake ({hotkey_ss58}): [blue]{stake_on_uid}[/blue] :arrow_right: [green]{new_stake}[/green]"
+ )
+ successful_unstakes += 1
+ else:
+ logging.error(":cross_mark: [red]Failed: Unknown Error.[/red]")
+ continue
+
+ except NotRegisteredError:
+ logging.error(
+ f":cross_mark: [red]Hotkey[/red] [blue]{hotkey_ss58}[/blue] [red]is not registered.[/red]"
+ )
+ continue
+ except StakeError as e:
+ logging.error(":cross_mark: [red]Stake Error: {}[/red]".format(e))
+ continue
+
+ if successful_unstakes != 0:
+ logging.info(
+ f":satellite: [magenta]Checking Balance on:[/magenta] ([blue]{subtensor.network}[/blue] [magenta]...[/magenta]"
+ )
+ new_balance = subtensor.get_balance(wallet.coldkeypub.ss58_address)
+ logging.info(
+ f"Balance: [blue]{old_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
+ )
+ return True
+
+ return False
diff --git a/bittensor/core/extrinsics/utils.py b/bittensor/core/extrinsics/utils.py
index 6c896372b6..6af14b25fb 100644
--- a/bittensor/core/extrinsics/utils.py
+++ b/bittensor/core/extrinsics/utils.py
@@ -1,21 +1,33 @@
"""Module with helper functions for extrinsics."""
+import threading
from typing import TYPE_CHECKING
-from substrateinterface.exceptions import SubstrateRequestException
+
+from substrateinterface.exceptions import SubstrateRequestException, ExtrinsicNotFound
+
from bittensor.utils.btlogging import logging
from bittensor.utils import format_error_message
if TYPE_CHECKING:
- from substrateinterface import SubstrateInterface
+ from substrateinterface import SubstrateInterface, ExtrinsicReceipt
from scalecodec.types import GenericExtrinsic
+class _ThreadingTimeoutException(Exception):
+ """
+ Exception raised for timeout. Different from TimeoutException because this also triggers
+ a websocket failure. This exception should only be used with `threading` timer..
+ """
+
+ pass
+
+
def submit_extrinsic(
substrate: "SubstrateInterface",
extrinsic: "GenericExtrinsic",
wait_for_inclusion: bool,
wait_for_finalization: bool,
-):
+) -> "ExtrinsicReceipt":
"""
Submits an extrinsic to the substrate blockchain and handles potential exceptions.
@@ -35,7 +47,22 @@ def submit_extrinsic(
Raises:
SubstrateRequestException: If the submission of the extrinsic fails, the error is logged and re-raised.
"""
+ extrinsic_hash = extrinsic.extrinsic_hash
+ starting_block = substrate.get_block()
+
+ def _handler():
+ """
+ Timeout handler for threading. Will raise a TimeoutError if timeout is exceeded.
+ """
+ logging.error("Timed out waiting for extrinsic submission.")
+ raise _ThreadingTimeoutException
+
+ # sets a timeout timer for the next call to 200 seconds
+ # will raise a _ThreadingTimeoutException if it reaches this point
+ timer = threading.Timer(200, _handler)
+
try:
+ timer.start()
response = substrate.submit_extrinsic(
extrinsic,
wait_for_inclusion=wait_for_inclusion,
@@ -46,4 +73,32 @@ def submit_extrinsic(
# Re-rise the exception for retrying of the extrinsic call. If we remove the retry logic, the raise will need
# to be removed.
raise
+
+ except _ThreadingTimeoutException:
+ after_timeout_block = substrate.get_block()
+
+ response = None
+ for block_num in range(
+ starting_block["header"]["number"],
+ after_timeout_block["header"]["number"] + 1,
+ ):
+ block_hash = substrate.get_block_hash(block_num)
+ try:
+ response = substrate.retrieve_extrinsic_by_hash(
+ block_hash, f"0x{extrinsic_hash.hex()}"
+ )
+ except ExtrinsicNotFound:
+ continue
+ if response:
+ break
+ finally:
+ timer.cancel()
+
+ if response is None:
+ logging.error(
+ f"Extrinsic '0x{extrinsic_hash.hex()}' not submitted. "
+ f"Initially attempted to submit at block {starting_block['header']['number']}."
+ )
+ raise SubstrateRequestException
+
return response
diff --git a/bittensor/core/settings.py b/bittensor/core/settings.py
index 8e8843b2e8..d7875bf4a4 100644
--- a/bittensor/core/settings.py
+++ b/bittensor/core/settings.py
@@ -15,7 +15,7 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
-__version__ = "8.3.1"
+__version__ = "8.4.0"
import os
import re
diff --git a/bittensor/core/subtensor.py b/bittensor/core/subtensor.py
index efaff369a4..fa46242277 100644
--- a/bittensor/core/subtensor.py
+++ b/bittensor/core/subtensor.py
@@ -1,28 +1,10 @@
-# The MIT License (MIT)
-# Copyright © 2024 Opentensor Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-# the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
"""
-The ``bittensor.core.subtensor.Subtensor`` module in Bittensor serves as a crucial interface for interacting with the Bittensor
-blockchain, facilitating a range of operations essential for the decentralized machine learning network.
+The ``bittensor.core.subtensor.Subtensor`` module in Bittensor serves as a crucial interface for interacting with the
+Bittensor blockchain, facilitating a range of operations essential for the decentralized machine learning network.
"""
import argparse
import copy
-import socket
import ssl
from typing import Union, Optional, TypedDict, Any
@@ -35,6 +17,7 @@
from scalecodec.type_registry import load_type_registry_preset
from scalecodec.types import ScaleType
from substrateinterface.base import QueryMapResult, SubstrateInterface
+from websockets.sync import client as ws_client
from bittensor.core import settings
from bittensor.core.axon import Axon
@@ -70,6 +53,14 @@
from bittensor.core.extrinsics.transfer import (
transfer_extrinsic,
)
+from bittensor.core.extrinsics.staking import (
+ add_stake_extrinsic,
+ add_stake_multiple_extrinsic,
+)
+from bittensor.core.extrinsics.unstaking import (
+ unstake_extrinsic,
+ unstake_multiple_extrinsic,
+)
from bittensor.core.metagraph import Metagraph
from bittensor.utils import (
networking,
@@ -77,6 +68,7 @@
ss58_to_vec_u8,
u16_normalized_float,
hex_to_bytes,
+ Certificate,
)
from bittensor.utils.balance import Balance
from bittensor.utils.btlogging import logging
@@ -148,6 +140,7 @@ def __init__(
_mock: bool = False,
log_verbose: bool = False,
connection_timeout: int = 600,
+ websocket: Optional[ws_client.ClientConnection] = None,
) -> None:
"""
Initializes a Subtensor interface for interacting with the Bittensor blockchain.
@@ -163,6 +156,7 @@ def __init__(
_mock (bool): If set to ``True``, uses a mocked connection for testing purposes. Default is ``False``.
log_verbose (bool): Whether to enable verbose logging. If set to ``True``, detailed log information about the connection and network operations will be provided. Default is ``True``.
connection_timeout (int): The maximum time in seconds to keep the connection alive. Default is ``600``.
+ websocket (websockets.sync.client.ClientConnection): websockets sync (threading) client object connected to the network.
This initialization sets up the connection to the specified Bittensor network, allowing for various blockchain operations such as neuron registration, stake management, and setting weights.
"""
@@ -199,6 +193,7 @@ def __init__(
self.log_verbose = log_verbose
self._connection_timeout = connection_timeout
self.substrate: "SubstrateInterface" = None
+ self.websocket = websocket
self._get_substrate()
def __str__(self) -> str:
@@ -221,31 +216,36 @@ def _get_substrate(self):
"""Establishes a connection to the Substrate node using configured parameters."""
try:
# Set up params.
+ if self.websocket is None or self.websocket.close_code is not None:
+ self.websocket = ws_client.connect(
+ self.chain_endpoint,
+ open_timeout=self._connection_timeout,
+ max_size=2**32,
+ )
self.substrate = SubstrateInterface(
ss58_format=settings.SS58_FORMAT,
use_remote_preset=True,
- url=self.chain_endpoint,
type_registry=settings.TYPE_REGISTRY,
+ websocket=self.websocket,
)
if self.log_verbose:
logging.debug(
f"Connected to {self.network} network and {self.chain_endpoint}."
)
- try:
- self.substrate.websocket.settimeout(self._connection_timeout)
- except (AttributeError, TypeError, socket.error, OSError) as e:
- logging.warning(f"Error setting timeout: {e}")
-
except (ConnectionRefusedError, ssl.SSLError) as error:
logging.error(
- f"Could not connect to {self.network} network with {self.chain_endpoint} chain endpoint.",
- )
- logging.info(
- "You can check if you have connectivity by running this command: nc -vz localhost "
- f"{self.chain_endpoint}"
+ f"Could not connect to {self.network} network with {self.chain_endpoint} chain endpoint.",
)
raise ConnectionRefusedError(error.args)
+ except ssl.SSLError as e:
+ logging.critical(
+ "SSL error occurred. To resolve this issue, run the following command in your terminal:"
+ )
+ logging.critical("[blue]sudo python -m bittensor certifi[/blue]")
+ raise RuntimeError(
+ "SSL configuration issue, please follow the instructions above."
+ ) from e
@staticmethod
def config() -> "Config":
@@ -436,7 +436,7 @@ def _get_hyperparameter(
return result.value
- # Calls methods
+ # Chain calls methods ==============================================================================================
@networking.ensure_connected
def query_subtensor(
self, name: str, block: Optional[int] = None, params: Optional[list] = None
@@ -650,7 +650,7 @@ def query_module(
),
)
- # Common subtensor methods
+ # Common subtensor methods =========================================================================================
def metagraph(
self, netuid: int, lite: bool = True, block: Optional[int] = None
) -> "Metagraph": # type: ignore
@@ -803,235 +803,6 @@ def is_hotkey_registered(
else:
return self.is_hotkey_registered_on_subnet(hotkey_ss58, netuid, block)
- # Not used in Bittensor, but is actively used by the community in almost all subnets
- def set_weights(
- self,
- wallet: "Wallet",
- netuid: int,
- uids: Union[NDArray[np.int64], "torch.LongTensor", list],
- weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
- version_key: int = settings.version_as_int,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = False,
- max_retries: int = 5,
- ) -> tuple[bool, str]:
- """
- Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or trust a neuron places on other neurons in the network, which is a fundamental aspect of Bittensor's decentralized learning architecture.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron setting the weights.
- netuid (int): The unique identifier of the subnet.
- uids (Union[NDArray[np.int64], torch.LongTensor, list]): The list of neuron UIDs that the weights are being set for.
- weights (Union[NDArray[np.float32], torch.FloatTensor, list]): The corresponding weights to be set for each UID.
- version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version.``.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
- max_retries (int): The number of maximum attempts to set weights. Default is ``5``.
-
- Returns:
- tuple[bool, str]: ``True`` if the setting of weights is successful, False otherwise. And `msg`, a string value describing the success or potential error.
-
- This function is crucial in shaping the network's collective intelligence, where each neuron's learning and contribution are influenced by the weights it sets towards others【81†source】.
- """
- uid = self.get_uid_for_hotkey_on_subnet(wallet.hotkey.ss58_address, netuid)
- retries = 0
- success = False
- message = "No attempt made. Perhaps it is too soon to set weights!"
- while (
- self.blocks_since_last_update(netuid, uid) > self.weights_rate_limit(netuid) # type: ignore
- and retries < max_retries
- ):
- try:
- logging.info(
- f"Setting weights for subnet #{netuid}. Attempt {retries + 1} of {max_retries}."
- )
- success, message = set_weights_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuid=netuid,
- uids=uids,
- weights=weights,
- version_key=version_key,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
- except Exception as e:
- logging.error(f"Error setting weights: {e}")
- finally:
- retries += 1
-
- return success, message
-
- @legacy_torch_api_compat
- def root_set_weights(
- self,
- wallet: "Wallet",
- netuids: Union[NDArray[np.int64], "torch.LongTensor", list],
- weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
- version_key: int = 0,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = False,
- ) -> bool:
- """
- Sets the weights for neurons on the root network. This action is crucial for defining the influence and interactions of neurons at the root level of the Bittensor network.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron setting the weights.
- netuids (Union[NDArray[np.int64], torch.LongTensor, list]): The list of neuron UIDs for which weights are being set.
- weights (Union[NDArray[np.float32], torch.FloatTensor, list]): The corresponding weights to be set for each UID.
- version_key (int, optional): Version key for compatibility with the network. Default is ``0``.
- wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block. Defaults to ``False``.
- wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain. Defaults to ``False``.
-
- Returns:
- bool: ``True`` if the setting of root-level weights is successful, False otherwise.
-
- This function plays a pivotal role in shaping the root network's collective intelligence and decision-making processes, reflecting the principles of decentralized governance and collaborative learning in Bittensor.
- """
- return set_root_weights_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuids=netuids,
- weights=weights,
- version_key=version_key,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
-
- def register(
- self,
- wallet: "Wallet",
- netuid: int,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = True,
- max_allowed_attempts: int = 3,
- output_in_place: bool = True,
- cuda: bool = False,
- dev_id: Union[list[int], int] = 0,
- tpb: int = 256,
- num_processes: Optional[int] = None,
- update_interval: Optional[int] = None,
- log_verbose: bool = False,
- ) -> bool:
- """
- Registers a neuron on the Bittensor network using the provided wallet.
-
- Registration is a critical step for a neuron to become an active participant in the network, enabling it to stake, set weights, and receive incentives.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron to be registered.
- netuid (int): The unique identifier of the subnet.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Defaults to `False`.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
- max_allowed_attempts (int): Maximum number of attempts to register the wallet.
- output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines. Defaults to `True`.
- cuda (bool): If ``true``, the wallet should be registered using CUDA device(s). Defaults to `False`.
- dev_id (Union[List[int], int]): The CUDA device id to use, or a list of device ids. Defaults to `0` (zero).
- tpb (int): The number of threads per block (CUDA). Default to `256`.
- num_processes (Optional[int]): The number of processes to use to register. Default to `None`.
- update_interval (Optional[int]): The number of nonces to solve between updates. Default to `None`.
- log_verbose (bool): If ``true``, the registration process will log more information. Default to `False`.
-
- Returns:
- bool: ``True`` if the registration is successful, False otherwise.
-
- This function facilitates the entry of new neurons into the network, supporting the decentralized
- growth and scalability of the Bittensor ecosystem.
- """
- return register_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuid=netuid,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- max_allowed_attempts=max_allowed_attempts,
- output_in_place=output_in_place,
- cuda=cuda,
- dev_id=dev_id,
- tpb=tpb,
- num_processes=num_processes,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
-
- def root_register(
- self,
- wallet: "Wallet",
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = True,
- ) -> bool:
- """
- Registers the neuron associated with the wallet on the root network. This process is integral for participating in the highest layer of decision-making and governance within the Bittensor network.
-
- Args:
- wallet (bittensor.wallet): The wallet associated with the neuron to be registered on the root network.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Defaults to `False`.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
-
- Returns:
- bool: ``True`` if the registration on the root network is successful, False otherwise.
-
- This function enables neurons to engage in the most critical and influential aspects of the network's governance, signifying a high level of commitment and responsibility in the Bittensor ecosystem.
- """
- return root_register_extrinsic(
- subtensor=self,
- wallet=wallet,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
-
- def burned_register(
- self,
- wallet: "Wallet",
- netuid: int,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = True,
- ) -> bool:
- """
- Registers a neuron on the Bittensor network by recycling TAO. This method of registration involves recycling TAO tokens, allowing them to be re-mined by performing work on the network.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron to be registered.
- netuid (int): The unique identifier of the subnet.
- wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block. Defaults to `False`.
- wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
-
- Returns:
- bool: ``True`` if the registration is successful, False otherwise.
- """
- return burned_register_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuid=netuid,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
-
- def serve_axon(
- self,
- netuid: int,
- axon: "Axon",
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = True,
- ) -> bool:
- """
- Registers an ``Axon`` serving endpoint on the Bittensor network for a specific neuron. This function is used to set up the Axon, a key component of a neuron that handles incoming queries and data processing tasks.
-
- Args:
- netuid (int): The unique identifier of the subnetwork.
- axon (bittensor.core.axon.Axon): The Axon instance to be registered for serving.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``True``.
-
- Returns:
- bool: ``True`` if the Axon serve registration is successful, False otherwise.
-
- By registering an Axon, the neuron becomes an active part of the network's distributed computing infrastructure, contributing to the collective intelligence of Bittensor.
- """
- return serve_axon_extrinsic(
- self, netuid, axon, wait_for_inclusion, wait_for_finalization
- )
-
# metagraph
@property
def block(self) -> int:
@@ -1084,8 +855,6 @@ def weights_rate_limit(self, netuid: int) -> Optional[int]:
call = self._get_hyperparameter(param_name="WeightsSetRateLimit", netuid=netuid)
return None if call is None else int(call)
- # Keep backwards compatibility for community usage.
- # Make some commitment on-chain about arbitrary data.
def commit(self, wallet, netuid: int, data: str):
"""
Commits arbitrary data to the Bittensor network by publishing metadata.
@@ -1097,7 +866,6 @@ def commit(self, wallet, netuid: int, data: str):
"""
publish_metadata(self, wallet, netuid, f"Raw{len(data)}", data.encode())
- # Keep backwards compatibility for community usage.
def subnetwork_n(self, netuid: int, block: Optional[int] = None) -> Optional[int]:
"""
Returns network SubnetworkN hyperparameter.
@@ -1114,61 +882,62 @@ def subnetwork_n(self, netuid: int, block: Optional[int] = None) -> Optional[int
)
return None if call is None else int(call)
- # Community uses this method
- def transfer(
- self,
- wallet: "Wallet",
- dest: str,
- amount: Union["Balance", float],
- wait_for_inclusion: bool = True,
- wait_for_finalization: bool = False,
- ) -> bool:
+ def get_neuron_for_pubkey_and_subnet(
+ self, hotkey_ss58: str, netuid: int, block: Optional[int] = None
+ ) -> Optional["NeuronInfo"]:
"""
- Executes a transfer of funds from the provided wallet to the specified destination address. This function is used to move TAO tokens within the Bittensor network, facilitating transactions between neurons.
+ Retrieves information about a neuron based on its public key (hotkey SS58 address) and the specific subnet UID (netuid). This function provides detailed neuron information for a particular subnet within the Bittensor network.
Args:
- wallet (bittensor_wallet.Wallet): The wallet from which funds are being transferred.
- dest (str): The destination public key address.
- amount (Union[bittensor.utils.balance.Balance, float]): The amount of TAO to be transferred.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``True``.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
+ hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
+ netuid (int): The unique identifier of the subnet.
+ block (Optional[int]): The blockchain block number at which to perform the query.
Returns:
- transfer_extrinsic (bool): ``True`` if the transfer is successful, False otherwise.
+ Optional[bittensor.core.chain_data.neuron_info.NeuronInfo]: Detailed information about the neuron if found, ``None`` otherwise.
- This function is essential for the fluid movement of tokens in the network, supporting various economic activities such as staking, delegation, and reward distribution.
+ This function is crucial for accessing specific neuron data and understanding its status, stake, and other attributes within a particular subnet of the Bittensor ecosystem.
"""
- return transfer_extrinsic(
- subtensor=self,
- wallet=wallet,
- dest=dest,
- amount=amount,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
+ return self.neuron_for_uid(
+ self.get_uid_for_hotkey_on_subnet(hotkey_ss58, netuid, block=block),
+ netuid,
+ block=block,
)
- # Community uses this method via `bittensor.api.extrinsics.prometheus.prometheus_extrinsic`
- def get_neuron_for_pubkey_and_subnet(
- self, hotkey_ss58: str, netuid: int, block: Optional[int] = None
- ) -> Optional["NeuronInfo"]:
+ def get_neuron_certificate(
+ self, hotkey: str, netuid: int, block: Optional[int] = None
+ ) -> Optional["Certificate"]:
"""
- Retrieves information about a neuron based on its public key (hotkey SS58 address) and the specific subnet UID (netuid). This function provides detailed neuron information for a particular subnet within the Bittensor network.
+ Retrieves the TLS certificate for a specific neuron identified by its unique identifier (UID)
+ within a specified subnet (netuid) of the Bittensor network.
Args:
- hotkey_ss58 (str): The ``SS58`` address of the neuron's hotkey.
+ hotkey (str): The hotkey to query.
netuid (int): The unique identifier of the subnet.
- block (Optional[int]): The blockchain block number at which to perform the query.
+ block (Optional[int], optional): The blockchain block number for the query.
Returns:
- Optional[bittensor.core.chain_data.neuron_info.NeuronInfo]: Detailed information about the neuron if found, ``None`` otherwise.
+ Optional[Certificate]: the certificate of the neuron if found, ``None`` otherwise.
- This function is crucial for accessing specific neuron data and understanding its status, stake, and other attributes within a particular subnet of the Bittensor ecosystem.
+ This function is used for certificate discovery for setting up mutual tls communication between neurons
"""
- return self.neuron_for_uid(
- self.get_uid_for_hotkey_on_subnet(hotkey_ss58, netuid, block=block),
- netuid,
+
+ certificate = self.query_module(
+ module="SubtensorModule",
+ name="NeuronCertificates",
block=block,
+ params=[netuid, hotkey],
)
+ try:
+ serialized_certificate = certificate.serialize()
+ if serialized_certificate:
+ return (
+ chr(serialized_certificate["algorithm"])
+ + serialized_certificate["public_key"]
+ )
+ except AttributeError:
+ return None
+ return None
@networking.ensure_connected
def neuron_for_uid(
@@ -1205,7 +974,6 @@ def neuron_for_uid(
return NeuronInfo.from_vec_u8(result)
- # Community uses this method
def get_subnet_hyperparameters(
self, netuid: int, block: Optional[int] = None
) -> Optional[Union[list, "SubnetHyperparameters"]]:
@@ -1233,8 +1001,6 @@ def get_subnet_hyperparameters(
return SubnetHyperparameters.from_vec_u8(hex_to_bytes(hex_bytes_result))
- # Community uses this method
- # Returns network ImmunityPeriod hyper parameter.
def immunity_period(
self, netuid: int, block: Optional[int] = None
) -> Optional[int]:
@@ -1255,7 +1021,6 @@ def immunity_period(
)
return None if call is None else int(call)
- # Community uses this method
def get_uid_for_hotkey_on_subnet(
self, hotkey_ss58: str, netuid: int, block: Optional[int] = None
) -> Optional[int]:
@@ -1275,7 +1040,6 @@ def get_uid_for_hotkey_on_subnet(
_result = self.query_subtensor("Uids", block, [netuid, hotkey_ss58])
return getattr(_result, "value", None)
- # Community uses this method
def tempo(self, netuid: int, block: Optional[int] = None) -> Optional[int]:
"""
Returns network Tempo hyperparameter.
@@ -1290,7 +1054,6 @@ def tempo(self, netuid: int, block: Optional[int] = None) -> Optional[int]:
call = self._get_hyperparameter(param_name="Tempo", netuid=netuid, block=block)
return None if call is None else int(call)
- # Community uses this method
def get_commitment(self, netuid: int, uid: int, block: Optional[int] = None) -> str:
"""
Retrieves the on-chain commitment for a specific neuron in the Bittensor network.
@@ -1315,7 +1078,6 @@ def get_commitment(self, netuid: int, uid: int, block: Optional[int] = None) ->
except TypeError:
return ""
- # Community uses this via `bittensor.utils.weight_utils.process_weights_for_netuid` function.
def min_allowed_weights(
self, netuid: int, block: Optional[int] = None
) -> Optional[int]:
@@ -1334,7 +1096,6 @@ def min_allowed_weights(
)
return None if call is None else int(call)
- # Community uses this via `bittensor.utils.weight_utils.process_weights_for_netuid` function.
def max_weight_limit(
self, netuid: int, block: Optional[int] = None
) -> Optional[float]:
@@ -1353,7 +1114,6 @@ def max_weight_limit(
)
return None if call is None else u16_normalized_float(int(call))
- # # Community uses this method. It is used in subtensor in neuron_info, and serving.
def get_prometheus_info(
self, netuid: int, hotkey_ss58: str, block: Optional[int] = None
) -> Optional["PrometheusInfo"]:
@@ -1379,7 +1139,6 @@ def get_prometheus_info(
)
return None
- # Community uses this method
def subnet_exists(self, netuid: int, block: Optional[int] = None) -> bool:
"""
Checks if a subnet with the specified unique identifier (netuid) exists within the Bittensor network.
@@ -1417,7 +1176,6 @@ def get_all_subnets_info(self, block: Optional[int] = None) -> list[SubnetInfo]:
else:
return SubnetInfo.list_from_vec_u8(hex_to_bytes(hex_bytes_result))
- # Metagraph uses this method
def bonds(
self, netuid: int, block: Optional[int] = None
) -> list[tuple[int, list[tuple[int, int]]]]:
@@ -1467,7 +1225,6 @@ def get_subnet_burn_cost(self, block: Optional[int] = None) -> Optional[str]:
return lock_cost
- # Metagraph uses this method
def neurons(self, netuid: int, block: Optional[int] = None) -> list["NeuronInfo"]:
"""
Retrieves a list of all neurons within a specified subnet of the Bittensor network. This function provides a snapshot of the subnet's neuron population, including each neuron's attributes and network interactions.
@@ -1497,7 +1254,6 @@ def neurons(self, netuid: int, block: Optional[int] = None) -> list["NeuronInfo"
return neurons
- # Metagraph uses this method
def get_total_subnets(self, block: Optional[int] = None) -> Optional[int]:
"""
Retrieves the total number of subnets within the Bittensor network as of a specific blockchain block.
@@ -1513,7 +1269,6 @@ def get_total_subnets(self, block: Optional[int] = None) -> Optional[int]:
_result = self.query_subtensor("TotalNetworks", block)
return getattr(_result, "value", None)
- # Metagraph uses this method
def get_subnets(self, block: Optional[int] = None) -> list[int]:
"""
Retrieves a list of all subnets currently active within the Bittensor network. This function provides an overview of the various subnets and their identifiers.
@@ -1533,7 +1288,6 @@ def get_subnets(self, block: Optional[int] = None) -> list[int]:
else []
)
- # Metagraph uses this method
def neurons_lite(
self, netuid: int, block: Optional[int] = None
) -> list["NeuronInfoLite"]:
@@ -1561,7 +1315,6 @@ def neurons_lite(
return NeuronInfoLite.list_from_vec_u8(hex_to_bytes(hex_bytes_result)) # type: ignore
- # Used in the `neurons` method which is used in metagraph.py
def weights(
self, netuid: int, block: Optional[int] = None
) -> list[tuple[int, list[tuple[int, int]]]]:
@@ -1587,7 +1340,6 @@ def weights(
return w_map
- # Used by community via `transfer_extrinsic`
@networking.ensure_connected
def get_balance(self, address: str, block: Optional[int] = None) -> "Balance":
"""
@@ -1620,7 +1372,6 @@ def get_balance(self, address: str, block: Optional[int] = None) -> "Balance":
return Balance(result.value["data"]["free"])
- # Used in community via `bittensor.core.subtensor.Subtensor.transfer`
@networking.ensure_connected
def get_transfer_fee(
self, wallet: "Wallet", dest: str, value: Union["Balance", float, int]
@@ -1655,7 +1406,7 @@ def get_transfer_fee(
call=call, keypair=wallet.coldkeypub
)
except Exception as e:
- logging.error(f"Failed to get payment info. {e}")
+ logging.error(f"[red]Failed to get payment info.[/red] {e}")
payment_info = {"partialFee": int(2e7)} # assume 0.02 Tao
fee = Balance.from_rao(payment_info["partialFee"])
@@ -1670,7 +1421,6 @@ def get_transfer_fee(
)
return fee
- # Used in community via `bittensor.core.subtensor.Subtensor.transfer`
def get_existential_deposit(
self, block: Optional[int] = None
) -> Optional["Balance"]:
@@ -1692,142 +1442,6 @@ def get_existential_deposit(
return None
return Balance.from_rao(result.value)
- # Community uses this method
- def commit_weights(
- self,
- wallet: "Wallet",
- netuid: int,
- salt: list[int],
- uids: Union[NDArray[np.int64], list],
- weights: Union[NDArray[np.int64], list],
- version_key: int = settings.version_as_int,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = False,
- max_retries: int = 5,
- ) -> tuple[bool, str]:
- """
- Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
- This action serves as a commitment or snapshot of the neuron's current weight distribution.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron committing the weights.
- netuid (int): The unique identifier of the subnet.
- salt (list[int]): list of randomly generated integers as salt to generated weighted hash.
- uids (np.ndarray): NumPy array of neuron UIDs for which weights are being committed.
- weights (np.ndarray): NumPy array of weight values corresponding to each UID.
- version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version.``.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
- max_retries (int): The number of maximum attempts to commit weights. Default is ``5``.
-
- Returns:
- tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string
- value describing the success or potential error.
-
- This function allows neurons to create a tamper-proof record of their weight distribution at a specific point in time,
- enhancing transparency and accountability within the Bittensor network.
- """
- retries = 0
- success = False
- message = "No attempt made. Perhaps it is too soon to commit weights!"
-
- logging.info(
- f"Committing weights with params: netuid={netuid}, uids={uids}, weights={weights}, version_key={version_key}"
- )
-
- # Generate the hash of the weights
- commit_hash = generate_weight_hash(
- address=wallet.hotkey.ss58_address,
- netuid=netuid,
- uids=list(uids),
- values=list(weights),
- salt=salt,
- version_key=version_key,
- )
-
- logging.info(f"Commit Hash: {commit_hash}")
-
- while retries < max_retries:
- try:
- success, message = commit_weights_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuid=netuid,
- commit_hash=commit_hash,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
- if success:
- break
- except Exception as e:
- logging.error(f"Error committing weights: {e}")
- finally:
- retries += 1
-
- return success, message
-
- # Community uses this method
- def reveal_weights(
- self,
- wallet: "Wallet",
- netuid: int,
- uids: Union[NDArray[np.int64], list],
- weights: Union[NDArray[np.int64], list],
- salt: Union[NDArray[np.int64], list],
- version_key: int = settings.version_as_int,
- wait_for_inclusion: bool = False,
- wait_for_finalization: bool = False,
- max_retries: int = 5,
- ) -> tuple[bool, str]:
- """
- Reveals the weights for a specific subnet on the Bittensor blockchain using the provided wallet.
- This action serves as a revelation of the neuron's previously committed weight distribution.
-
- Args:
- wallet (bittensor_wallet.Wallet): The wallet associated with the neuron revealing the weights.
- netuid (int): The unique identifier of the subnet.
- uids (np.ndarray): NumPy array of neuron UIDs for which weights are being revealed.
- weights (np.ndarray): NumPy array of weight values corresponding to each UID.
- salt (np.ndarray): NumPy array of salt values corresponding to the hash function.
- version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version``.
- wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
- wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
- max_retries (int): The number of maximum attempts to reveal weights. Default is ``5``.
-
- Returns:
- tuple[bool, str]: ``True`` if the weight revelation is successful, False otherwise. And `msg`, a string
- value describing the success or potential error.
-
- This function allows neurons to reveal their previously committed weight distribution, ensuring transparency
- and accountability within the Bittensor network.
- """
-
- retries = 0
- success = False
- message = "No attempt made. Perhaps it is too soon to reveal weights!"
-
- while retries < max_retries:
- try:
- success, message = reveal_weights_extrinsic(
- subtensor=self,
- wallet=wallet,
- netuid=netuid,
- uids=list(uids),
- weights=list(weights),
- salt=list(salt),
- version_key=version_key,
- wait_for_inclusion=wait_for_inclusion,
- wait_for_finalization=wait_for_finalization,
- )
- if success:
- break
- except Exception as e:
- logging.error(f"Error revealing weights: {e}")
- finally:
- retries += 1
-
- return success, message
-
def difficulty(self, netuid: int, block: Optional[int] = None) -> Optional[int]:
"""
Retrieves the 'Difficulty' hyperparameter for a specified subnet in the Bittensor network.
@@ -1918,5 +1532,667 @@ def get_delegate_by_hotkey(
return DelegateInfo.from_vec_u8(bytes(result))
- # Subnet 27 uses this method name
- _do_serve_axon = do_serve_axon
+ def get_stake_for_coldkey_and_hotkey(
+ self, hotkey_ss58: str, coldkey_ss58: str, block: Optional[int] = None
+ ) -> Optional["Balance"]:
+ """
+ Returns the stake under a coldkey - hotkey pairing.
+
+ Args:
+ hotkey_ss58 (str): The SS58 address of the hotkey.
+ coldkey_ss58 (str): The SS58 address of the coldkey.
+ block (Optional[int]): The block number to retrieve the stake from. If ``None``, the latest block is used. Default is ``None``.
+
+ Returns:
+ Optional[Balance]: The stake under the coldkey - hotkey pairing, or ``None`` if the pairing does not exist or the stake is not found.
+ """
+ result = self.query_subtensor("Stake", block, [hotkey_ss58, coldkey_ss58])
+ return (
+ None
+ if getattr(result, "value", None) is None
+ else Balance.from_rao(result.value)
+ )
+
+ def does_hotkey_exist(self, hotkey_ss58: str, block: Optional[int] = None) -> bool:
+ """
+ Returns true if the hotkey is known by the chain and there are accounts.
+
+ Args:
+ hotkey_ss58 (str): The SS58 address of the hotkey.
+ block (Optional[int]): The block number to check the hotkey against. If ``None``, the latest block is used. Default is ``None``.
+
+ Returns:
+ bool: ``True`` if the hotkey is known by the chain and there are accounts, ``False`` otherwise.
+ """
+ result = self.query_subtensor("Owner", block, [hotkey_ss58])
+ return (
+ False
+ if getattr(result, "value", None) is None
+ else result.value != "5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM"
+ )
+
+ def get_hotkey_owner(
+ self, hotkey_ss58: str, block: Optional[int] = None
+ ) -> Optional[str]:
+ """
+ Returns the coldkey owner of the passed hotkey.
+
+ Args:
+ hotkey_ss58 (str): The SS58 address of the hotkey.
+ block (Optional[int]): The block number to check the hotkey owner against. If ``None``, the latest block is used. Default is ``None``.
+
+ Returns:
+ Optional[str]: The SS58 address of the coldkey owner, or ``None`` if the hotkey does not exist or the owner is not found.
+ """
+ result = self.query_subtensor("Owner", block, [hotkey_ss58])
+ return (
+ None
+ if getattr(result, "value", None) is None
+ or not self.does_hotkey_exist(hotkey_ss58, block)
+ else result.value
+ )
+
+ @networking.ensure_connected
+ def get_minimum_required_stake(
+ self,
+ ) -> Balance:
+ """
+ Returns the minimum required stake for nominators in the Subtensor network.
+
+ This method retries the substrate call up to three times with exponential backoff in case of failures.
+
+ Returns:
+ Balance: The minimum required stake as a Balance object.
+
+ Raises:
+ Exception: If the substrate call fails after the maximum number of retries.
+ """
+
+ result = self.substrate.query(
+ module="SubtensorModule", storage_function="NominatorMinRequiredStake"
+ )
+ return Balance.from_rao(result.decode())
+
+ def tx_rate_limit(self, block: Optional[int] = None) -> Optional[int]:
+ """
+ Retrieves the transaction rate limit for the Bittensor network as of a specific blockchain block.
+ This rate limit sets the maximum number of transactions that can be processed within a given time frame.
+
+ Args:
+ block (Optional[int]): The blockchain block number at which to perform the query.
+
+ Returns:
+ Optional[int]: The transaction rate limit of the network, None if not available.
+
+ The transaction rate limit is an essential parameter for ensuring the stability and scalability of the Bittensor network. It helps in managing network load and preventing congestion, thereby maintaining efficient and timely transaction processing.
+ """
+ result = self.query_subtensor("TxRateLimit", block)
+ return getattr(result, "value", None)
+
+ @networking.ensure_connected
+ def get_delegates(self, block: Optional[int] = None) -> list[DelegateInfo]:
+ """
+ Retrieves a list of all delegate neurons within the Bittensor network. This function provides an overview of the neurons that are actively involved in the network's delegation system.
+
+ Analyzing the delegate population offers insights into the network's governance dynamics and the distribution of trust and responsibility among participating neurons.
+
+ Args:
+ block (Optional[int]): The blockchain block number for the query.
+
+ Returns:
+ list[DelegateInfo]: A list of DelegateInfo objects detailing each delegate's characteristics.
+
+ """
+ block_hash = None if block is None else self.substrate.get_block_hash(block)
+
+ json_body = self.substrate.rpc_request(
+ method="delegateInfo_getDelegates",
+ params=[block_hash] if block_hash else [],
+ )
+
+ if not (result := json_body.get("result", None)):
+ return []
+
+ return DelegateInfo.list_from_vec_u8(result)
+
+ def is_hotkey_delegate(self, hotkey_ss58: str, block: Optional[int] = None) -> bool:
+ """
+ Determines whether a given hotkey (public key) is a delegate on the Bittensor network. This function checks if the neuron associated with the hotkey is part of the network's delegation system.
+
+ Args:
+ hotkey_ss58 (str): The SS58 address of the neuron's hotkey.
+ block (Optional[int]): The blockchain block number for the query.
+
+ Returns:
+ bool: ``True`` if the hotkey is a delegate, ``False`` otherwise.
+
+ Being a delegate is a significant status within the Bittensor network, indicating a neuron's involvement in consensus and governance processes.
+ """
+ return hotkey_ss58 in [
+ info.hotkey_ss58 for info in self.get_delegates(block=block)
+ ]
+
+ # Extrinsics =======================================================================================================
+
+ def set_weights(
+ self,
+ wallet: "Wallet",
+ netuid: int,
+ uids: Union[NDArray[np.int64], "torch.LongTensor", list],
+ weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
+ version_key: int = settings.version_as_int,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = False,
+ max_retries: int = 5,
+ ) -> tuple[bool, str]:
+ """
+ Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or trust a neuron places on other neurons in the network, which is a fundamental aspect of Bittensor's decentralized learning architecture.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron setting the weights.
+ netuid (int): The unique identifier of the subnet.
+ uids (Union[NDArray[np.int64], torch.LongTensor, list]): The list of neuron UIDs that the weights are being set for.
+ weights (Union[NDArray[np.float32], torch.FloatTensor, list]): The corresponding weights to be set for each UID.
+ version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version.``.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
+ max_retries (int): The number of maximum attempts to set weights. Default is ``5``.
+
+ Returns:
+ tuple[bool, str]: ``True`` if the setting of weights is successful, False otherwise. And `msg`, a string value describing the success or potential error.
+
+ This function is crucial in shaping the network's collective intelligence, where each neuron's learning and contribution are influenced by the weights it sets towards others【81†source】.
+ """
+ uid = self.get_uid_for_hotkey_on_subnet(wallet.hotkey.ss58_address, netuid)
+ retries = 0
+ success = False
+ message = "No attempt made. Perhaps it is too soon to set weights!"
+ while (
+ self.blocks_since_last_update(netuid, uid) > self.weights_rate_limit(netuid) # type: ignore
+ and retries < max_retries
+ ):
+ try:
+ logging.info(
+ f"Setting weights for subnet #{netuid}. Attempt {retries + 1} of {max_retries}."
+ )
+ success, message = set_weights_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuid=netuid,
+ uids=uids,
+ weights=weights,
+ version_key=version_key,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+ except Exception as e:
+ logging.error(f"Error setting weights: {e}")
+ finally:
+ retries += 1
+
+ return success, message
+
+ @legacy_torch_api_compat
+ def root_set_weights(
+ self,
+ wallet: "Wallet",
+ netuids: Union[NDArray[np.int64], "torch.LongTensor", list],
+ weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
+ version_key: int = 0,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Sets the weights for neurons on the root network. This action is crucial for defining the influence and interactions of neurons at the root level of the Bittensor network.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron setting the weights.
+ netuids (Union[NDArray[np.int64], torch.LongTensor, list]): The list of neuron UIDs for which weights are being set.
+ weights (Union[NDArray[np.float32], torch.FloatTensor, list]): The corresponding weights to be set for each UID.
+ version_key (int, optional): Version key for compatibility with the network. Default is ``0``.
+ wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block. Defaults to ``False``.
+ wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain. Defaults to ``False``.
+
+ Returns:
+ bool: ``True`` if the setting of root-level weights is successful, False otherwise.
+
+ This function plays a pivotal role in shaping the root network's collective intelligence and decision-making processes, reflecting the principles of decentralized governance and collaborative learning in Bittensor.
+ """
+ return set_root_weights_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuids=netuids,
+ weights=weights,
+ version_key=version_key,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def register(
+ self,
+ wallet: "Wallet",
+ netuid: int,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = True,
+ max_allowed_attempts: int = 3,
+ output_in_place: bool = True,
+ cuda: bool = False,
+ dev_id: Union[list[int], int] = 0,
+ tpb: int = 256,
+ num_processes: Optional[int] = None,
+ update_interval: Optional[int] = None,
+ log_verbose: bool = False,
+ ) -> bool:
+ """
+ Registers a neuron on the Bittensor network using the provided wallet.
+
+ Registration is a critical step for a neuron to become an active participant in the network, enabling it to stake, set weights, and receive incentives.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron to be registered.
+ netuid (int): The unique identifier of the subnet.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Defaults to `False`.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
+ max_allowed_attempts (int): Maximum number of attempts to register the wallet.
+ output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines. Defaults to `True`.
+ cuda (bool): If ``true``, the wallet should be registered using CUDA device(s). Defaults to `False`.
+ dev_id (Union[List[int], int]): The CUDA device id to use, or a list of device ids. Defaults to `0` (zero).
+ tpb (int): The number of threads per block (CUDA). Default to `256`.
+ num_processes (Optional[int]): The number of processes to use to register. Default to `None`.
+ update_interval (Optional[int]): The number of nonces to solve between updates. Default to `None`.
+ log_verbose (bool): If ``true``, the registration process will log more information. Default to `False`.
+
+ Returns:
+ bool: ``True`` if the registration is successful, False otherwise.
+
+ This function facilitates the entry of new neurons into the network, supporting the decentralized
+ growth and scalability of the Bittensor ecosystem.
+ """
+ return register_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuid=netuid,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ max_allowed_attempts=max_allowed_attempts,
+ output_in_place=output_in_place,
+ cuda=cuda,
+ dev_id=dev_id,
+ tpb=tpb,
+ num_processes=num_processes,
+ update_interval=update_interval,
+ log_verbose=log_verbose,
+ )
+
+ def root_register(
+ self,
+ wallet: "Wallet",
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = True,
+ ) -> bool:
+ """
+ Registers the neuron associated with the wallet on the root network. This process is integral for participating in the highest layer of decision-making and governance within the Bittensor network.
+
+ Args:
+ wallet (bittensor_wallet.wallet): The wallet associated with the neuron to be registered on the root network.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Defaults to `False`.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
+
+ Returns:
+ bool: ``True`` if the registration on the root network is successful, False otherwise.
+
+ This function enables neurons to engage in the most critical and influential aspects of the network's governance, signifying a high level of commitment and responsibility in the Bittensor ecosystem.
+ """
+ return root_register_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def burned_register(
+ self,
+ wallet: "Wallet",
+ netuid: int,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = True,
+ ) -> bool:
+ """
+ Registers a neuron on the Bittensor network by recycling TAO. This method of registration involves recycling TAO tokens, allowing them to be re-mined by performing work on the network.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron to be registered.
+ netuid (int): The unique identifier of the subnet.
+ wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block. Defaults to `False`.
+ wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain. Defaults to `True`.
+
+ Returns:
+ bool: ``True`` if the registration is successful, False otherwise.
+ """
+ return burned_register_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuid=netuid,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def serve_axon(
+ self,
+ netuid: int,
+ axon: "Axon",
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = True,
+ certificate: Optional[Certificate] = None,
+ ) -> bool:
+ """
+ Registers an ``Axon`` serving endpoint on the Bittensor network for a specific neuron. This function is used to set up the Axon, a key component of a neuron that handles incoming queries and data processing tasks.
+
+ Args:
+ netuid (int): The unique identifier of the subnetwork.
+ axon (bittensor.core.axon.Axon): The Axon instance to be registered for serving.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``True``.
+
+ Returns:
+ bool: ``True`` if the Axon serve registration is successful, False otherwise.
+
+ By registering an Axon, the neuron becomes an active part of the network's distributed computing infrastructure, contributing to the collective intelligence of Bittensor.
+ """
+ return serve_axon_extrinsic(
+ self, netuid, axon, wait_for_inclusion, wait_for_finalization, certificate
+ )
+
+ _do_serve_axon = do_serve_axon
+
+ def transfer(
+ self,
+ wallet: "Wallet",
+ dest: str,
+ amount: Union["Balance", float],
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Executes a transfer of funds from the provided wallet to the specified destination address. This function is used to move TAO tokens within the Bittensor network, facilitating transactions between neurons.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet from which funds are being transferred.
+ dest (str): The destination public key address.
+ amount (Union[bittensor.utils.balance.Balance, float]): The amount of TAO to be transferred.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``True``.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
+
+ Returns:
+ transfer_extrinsic (bool): ``True`` if the transfer is successful, False otherwise.
+
+ This function is essential for the fluid movement of tokens in the network, supporting various economic activities such as staking, delegation, and reward distribution.
+ """
+ return transfer_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ dest=dest,
+ amount=amount,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def commit_weights(
+ self,
+ wallet: "Wallet",
+ netuid: int,
+ salt: list[int],
+ uids: Union[NDArray[np.int64], list],
+ weights: Union[NDArray[np.int64], list],
+ version_key: int = settings.version_as_int,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = False,
+ max_retries: int = 5,
+ ) -> tuple[bool, str]:
+ """
+ Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
+ This action serves as a commitment or snapshot of the neuron's current weight distribution.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron committing the weights.
+ netuid (int): The unique identifier of the subnet.
+ salt (list[int]): list of randomly generated integers as salt to generated weighted hash.
+ uids (np.ndarray): NumPy array of neuron UIDs for which weights are being committed.
+ weights (np.ndarray): NumPy array of weight values corresponding to each UID.
+ version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version.``.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
+ max_retries (int): The number of maximum attempts to commit weights. Default is ``5``.
+
+ Returns:
+ tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string value describing the success or potential error.
+
+ This function allows neurons to create a tamper-proof record of their weight distribution at a specific point in time, enhancing transparency and accountability within the Bittensor network.
+ """
+ retries = 0
+ success = False
+ message = "No attempt made. Perhaps it is too soon to commit weights!"
+
+ logging.info(
+ f"Committing weights with params: netuid={netuid}, uids={uids}, weights={weights}, version_key={version_key}"
+ )
+
+ # Generate the hash of the weights
+ commit_hash = generate_weight_hash(
+ address=wallet.hotkey.ss58_address,
+ netuid=netuid,
+ uids=list(uids),
+ values=list(weights),
+ salt=salt,
+ version_key=version_key,
+ )
+
+ logging.info(f"Commit Hash: {commit_hash}")
+
+ while retries < max_retries:
+ try:
+ success, message = commit_weights_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuid=netuid,
+ commit_hash=commit_hash,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+ if success:
+ break
+ except Exception as e:
+ logging.error(f"Error committing weights: {e}")
+ finally:
+ retries += 1
+
+ return success, message
+
+ def reveal_weights(
+ self,
+ wallet: "Wallet",
+ netuid: int,
+ uids: Union[NDArray[np.int64], list],
+ weights: Union[NDArray[np.int64], list],
+ salt: Union[NDArray[np.int64], list],
+ version_key: int = settings.version_as_int,
+ wait_for_inclusion: bool = False,
+ wait_for_finalization: bool = False,
+ max_retries: int = 5,
+ ) -> tuple[bool, str]:
+ """
+ Reveals the weights for a specific subnet on the Bittensor blockchain using the provided wallet.
+ This action serves as a revelation of the neuron's previously committed weight distribution.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet associated with the neuron revealing the weights.
+ netuid (int): The unique identifier of the subnet.
+ uids (np.ndarray): NumPy array of neuron UIDs for which weights are being revealed.
+ weights (np.ndarray): NumPy array of weight values corresponding to each UID.
+ salt (np.ndarray): NumPy array of salt values corresponding to the hash function.
+ version_key (int): Version key for compatibility with the network. Default is ``int representation of Bittensor version``.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block. Default is ``False``.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain. Default is ``False``.
+ max_retries (int): The number of maximum attempts to reveal weights. Default is ``5``.
+
+ Returns:
+ tuple[bool, str]: ``True`` if the weight revelation is successful, False otherwise. And `msg`, a string value describing the success or potential error.
+
+ This function allows neurons to reveal their previously committed weight distribution, ensuring transparency and accountability within the Bittensor network.
+ """
+
+ retries = 0
+ success = False
+ message = "No attempt made. Perhaps it is too soon to reveal weights!"
+
+ while retries < max_retries:
+ try:
+ success, message = reveal_weights_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ netuid=netuid,
+ uids=list(uids),
+ weights=list(weights),
+ salt=list(salt),
+ version_key=version_key,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+ if success:
+ break
+ except Exception as e:
+ logging.error(f"Error revealing weights: {e}")
+ finally:
+ retries += 1
+
+ return success, message
+
+ def add_stake(
+ self,
+ wallet: "Wallet",
+ hotkey_ss58: Optional[str] = None,
+ amount: Optional[Union["Balance", float]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Adds the specified amount of stake to a neuron identified by the hotkey ``SS58`` address.
+ Staking is a fundamental process in the Bittensor network that enables neurons to participate actively and earn incentives.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet to be used for staking.
+ hotkey_ss58 (Optional[str]): The ``SS58`` address of the hotkey associated with the neuron.
+ amount (Union[Balance, float]): The amount of TAO to stake.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
+
+ Returns:
+ bool: ``True`` if the staking is successful, False otherwise.
+
+ This function enables neurons to increase their stake in the network, enhancing their influence and potential rewards in line with Bittensor's consensus and reward mechanisms.
+ """
+ return add_stake_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=amount,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def add_stake_multiple(
+ self,
+ wallet: "Wallet",
+ hotkey_ss58s: list[str],
+ amounts: Optional[list[Union["Balance", float]]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Adds stakes to multiple neurons identified by their hotkey SS58 addresses.
+ This bulk operation allows for efficient staking across different neurons from a single wallet.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet used for staking.
+ hotkey_ss58s (list[str]): List of ``SS58`` addresses of hotkeys to stake to.
+ amounts (list[Union[Balance, float]]): Corresponding amounts of TAO to stake for each hotkey.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
+
+ Returns:
+ bool: ``True`` if the staking is successful for all specified neurons, False otherwise.
+
+ This function is essential for managing stakes across multiple neurons, reflecting the dynamic and collaborative nature of the Bittensor network.
+ """
+ return add_stake_multiple_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ hotkey_ss58s=hotkey_ss58s,
+ amounts=amounts,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def unstake(
+ self,
+ wallet: "Wallet",
+ hotkey_ss58: Optional[str] = None,
+ amount: Optional[Union["Balance", float]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Removes a specified amount of stake from a single hotkey account. This function is critical for adjusting individual neuron stakes within the Bittensor network.
+
+ Args:
+ wallet (bittensor_wallet.wallet): The wallet associated with the neuron from which the stake is being removed.
+ hotkey_ss58 (Optional[str]): The ``SS58`` address of the hotkey account to unstake from.
+ amount (Union[Balance, float]): The amount of TAO to unstake. If not specified, unstakes all.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
+
+ Returns:
+ bool: ``True`` if the unstaking process is successful, False otherwise.
+
+ This function supports flexible stake management, allowing neurons to adjust their network participation and potential reward accruals.
+ """
+ return unstake_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ hotkey_ss58=hotkey_ss58,
+ amount=amount,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
+
+ def unstake_multiple(
+ self,
+ wallet: "Wallet",
+ hotkey_ss58s: list[str],
+ amounts: Optional[list[Union["Balance", float]]] = None,
+ wait_for_inclusion: bool = True,
+ wait_for_finalization: bool = False,
+ ) -> bool:
+ """
+ Performs batch unstaking from multiple hotkey accounts, allowing a neuron to reduce its staked amounts efficiently. This function is useful for managing the distribution of stakes across multiple neurons.
+
+ Args:
+ wallet (bittensor_wallet.Wallet): The wallet linked to the coldkey from which the stakes are being withdrawn.
+ hotkey_ss58s (List[str]): A list of hotkey ``SS58`` addresses to unstake from.
+ amounts (List[Union[Balance, float]]): The amounts of TAO to unstake from each hotkey. If not provided, unstakes all available stakes.
+ wait_for_inclusion (bool): Waits for the transaction to be included in a block.
+ wait_for_finalization (bool): Waits for the transaction to be finalized on the blockchain.
+
+ Returns:
+ bool: ``True`` if the batch unstaking is successful, False otherwise.
+
+ This function allows for strategic reallocation or withdrawal of stakes, aligning with the dynamic stake management aspect of the Bittensor network.
+ """
+ return unstake_multiple_extrinsic(
+ subtensor=self,
+ wallet=wallet,
+ hotkey_ss58s=hotkey_ss58s,
+ amounts=amounts,
+ wait_for_inclusion=wait_for_inclusion,
+ wait_for_finalization=wait_for_finalization,
+ )
diff --git a/bittensor/core/types.py b/bittensor/core/types.py
index 9fd2b4d052..577df5b6ba 100644
--- a/bittensor/core/types.py
+++ b/bittensor/core/types.py
@@ -15,7 +15,8 @@
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
-from typing import TypedDict
+from typing import TypedDict, Optional
+from bittensor.utils import Certificate
class AxonServeCallParams(TypedDict):
@@ -26,6 +27,7 @@ class AxonServeCallParams(TypedDict):
port: int
ip_type: int
netuid: int
+ certificate: Optional[Certificate]
class PrometheusServeCallParams(TypedDict):
diff --git a/bittensor/utils/__init__.py b/bittensor/utils/__init__.py
index 7a42dff0cf..90bd593a9f 100644
--- a/bittensor/utils/__init__.py
+++ b/bittensor/utils/__init__.py
@@ -40,6 +40,8 @@
U16_MAX = 65535
U64_MAX = 18446744073709551615
+Certificate = str
+
UnlockStatus = namedtuple("UnlockStatus", ["success", "message"])
@@ -216,7 +218,7 @@ def format_error_message(
err_description = err_docs[0] if err_docs else err_description
except (AttributeError, IndexError):
logging.error(
- "Substrate pallets data unavailable. This is usually caused by an uninitialized substrate."
+ "[red]Substrate pallets data unavailable. This is usually caused by an uninitialized substrate.[/red]"
)
else:
err_description = err_data
diff --git a/bittensor/utils/async_substrate_interface.py b/bittensor/utils/async_substrate_interface.py
index c3af691952..cd50695492 100644
--- a/bittensor/utils/async_substrate_interface.py
+++ b/bittensor/utils/async_substrate_interface.py
@@ -1,16 +1,21 @@
+"""
+This library comprises the asyncio-compatible version of the subtensor interface commands we use in bittensor, as
+well as its helper functions and classes. The docstring for the `AsyncSubstrateInterface` class goes more in-depth in
+regard to how to instantiate and use it.
+"""
+
import asyncio
+import inspect
import json
import random
from collections import defaultdict
from dataclasses import dataclass
from hashlib import blake2b
-from typing import Optional, Any, Union, Callable, Awaitable, cast
+from typing import Optional, Any, Union, Callable, Awaitable, cast, TYPE_CHECKING
-import websockets
from async_property import async_property
from bittensor_wallet import Keypair
from bt_decode import PortableRegistry, decode as decode_by_type_string, MetadataV15
-from packaging import version
from scalecodec import GenericExtrinsic
from scalecodec.base import ScaleBytes, ScaleType, RuntimeConfigurationObject
from scalecodec.type_registry import load_type_registry_preset
@@ -21,6 +26,13 @@
BlockNotFound,
)
from substrateinterface.storage import StorageKey
+from websockets.asyncio.client import connect
+from websockets.exceptions import ConnectionClosed
+
+from bittensor.utils import hex_to_bytes
+
+if TYPE_CHECKING:
+ from websockets.asyncio.client import ClientConnection
ResultHandler = Callable[[dict, Any], Awaitable[tuple[dict, bool]]]
@@ -52,12 +64,11 @@ def __init__(
Object containing information of submitted extrinsic. Block hash where extrinsic is included is required
when retrieving triggered events or determine if extrinsic was successful
- Parameters
- ----------
- substrate
- extrinsic_hash
- block_hash
- finalized
+ Args:
+ substrate: the AsyncSubstrateInterface instance
+ extrinsic_hash: the hash of the extrinsic
+ block_hash: the hash of the block on which this extrinsic exists
+ finalized: whether the extrinsic is finalized
"""
self.substrate = substrate
self.extrinsic_hash = extrinsic_hash
@@ -461,6 +472,9 @@ def __init__(self, chain, runtime_config, metadata, type_registry):
self.runtime_config = runtime_config
self.metadata = metadata
+ def __str__(self):
+ return f"Runtime: {self.chain} | {self.config}"
+
@property
def implements_scaleinfo(self) -> bool:
"""
@@ -478,15 +492,11 @@ def reload_type_registry(
Reload type registry and preset used to instantiate the SubstrateInterface object. Useful to periodically apply
changes in type definitions when a runtime upgrade occurred
- Parameters
- ----------
- use_remote_preset: When True preset is downloaded from Github master, otherwise use files from local installed
- scalecodec package
- auto_discover
-
- Returns
- -------
-
+ Args:
+ use_remote_preset: When True preset is downloaded from Github master, otherwise use files from local installed
+ scalecodec package
+ auto_discover: Whether to automatically discover the type registry presets based on the chain name and the
+ type registry
"""
self.runtime_config.clear_type_registry()
@@ -505,8 +515,10 @@ def apply_type_registry_presets(
):
"""
Applies type registry presets to the runtime
- :param use_remote_preset: bool, whether to use presets from remote
- :param auto_discover: bool, whether to use presets from local installed scalecodec package
+
+ Args:
+ use_remote_preset: whether to use presets from remote
+ auto_discover: whether to use presets from local installed scalecodec package
"""
if self.type_registry_preset is not None:
# Load type registry according to preset
@@ -614,15 +626,16 @@ def __init__(
Websocket manager object. Allows for the use of a single websocket connection by multiple
calls.
- :param ws_url: Websocket URL to connect to
- :param max_subscriptions: Maximum number of subscriptions per websocket connection
- :param max_connections: Maximum number of connections total
- :param shutdown_timer: Number of seconds to shut down websocket connection after last use
+ Args:
+ ws_url: Websocket URL to connect to
+ max_subscriptions: Maximum number of subscriptions per websocket connection
+ max_connections: Maximum number of connections total
+ shutdown_timer: Number of seconds to shut down websocket connection after last use
"""
# TODO allow setting max concurrent connections and rpc subscriptions per connection
# TODO reconnection logic
self.ws_url = ws_url
- self.ws: Optional[websockets.WebSocketClientProtocol] = None
+ self.ws: Optional["ClientConnection"] = None
self.id = 0
self.max_subscriptions = max_subscriptions
self.max_connections = max_connections
@@ -644,15 +657,12 @@ async def __aenter__(self):
self._exit_task.cancel()
if not self._initialized:
self._initialized = True
- await self._connect()
+ self.ws = await asyncio.wait_for(
+ connect(self.ws_url, **self._options), timeout=10
+ )
self._receiving_task = asyncio.create_task(self._start_receiving())
return self
- async def _connect(self):
- self.ws = await asyncio.wait_for(
- websockets.connect(self.ws_url, **self._options), timeout=10
- )
-
async def __aexit__(self, exc_type, exc_val, exc_tb):
async with self._lock:
self._in_use -= 1
@@ -693,9 +703,7 @@ async def shutdown(self):
async def _recv(self) -> None:
try:
- response = json.loads(
- await cast(websockets.WebSocketClientProtocol, self.ws).recv()
- )
+ response = json.loads(await self.ws.recv())
async with self._lock:
self._open_subscriptions -= 1
if "id" in response:
@@ -704,7 +712,7 @@ async def _recv(self) -> None:
self._received[response["params"]["subscription"]] = response
else:
raise KeyError(response)
- except websockets.ConnectionClosed:
+ except ConnectionClosed:
raise
except KeyError as e:
raise e
@@ -715,7 +723,7 @@ async def _start_receiving(self):
await self._recv()
except asyncio.CancelledError:
pass
- except websockets.ConnectionClosed:
+ except ConnectionClosed:
# TODO try reconnect, but only if it's needed
raise
@@ -723,7 +731,8 @@ async def send(self, payload: dict) -> int:
"""
Sends a payload to the websocket connection.
- :param payload: payload, generate a payload with the AsyncSubstrateInterface.make_payload method
+ Args:
+ payload: payload, generate a payload with the AsyncSubstrateInterface.make_payload method
"""
async with self._lock:
original_id = self.id
@@ -732,16 +741,18 @@ async def send(self, payload: dict) -> int:
try:
await self.ws.send(json.dumps({**payload, **{"id": original_id}}))
return original_id
- except websockets.ConnectionClosed:
+ except ConnectionClosed:
raise
async def retrieve(self, item_id: int) -> Optional[dict]:
"""
Retrieves a single item from received responses dict queue
- :param item_id: id of the item to retrieve
+ Args:
+ item_id: id of the item to retrieve
- :return: retrieved item
+ Returns:
+ retrieved item
"""
while True:
async with self._lock:
@@ -757,31 +768,40 @@ class AsyncSubstrateInterface:
def __init__(
self,
chain_endpoint: str,
- use_remote_preset=False,
- auto_discover=True,
- auto_reconnect=True,
- ss58_format=None,
- type_registry=None,
- chain_name=None,
+ use_remote_preset: bool = False,
+ auto_discover: bool = True,
+ ss58_format: Optional[int] = None,
+ type_registry: Optional[dict] = None,
+ chain_name: Optional[str] = None,
):
"""
- The asyncio-compatible version of the subtensor interface commands we use in bittensor
+ The asyncio-compatible version of the subtensor interface commands we use in bittensor. It is important to
+ initialise this class asynchronously in an async context manager using `async with AsyncSubstrateInterface()`.
+ Otherwise, some (most) methods will not work properly, and may raise exceptions.
+
+ Args:
+ chain_endpoint: the URI of the chain to connect to
+ use_remote_preset: whether to pull the preset from GitHub
+ auto_discover: whether to automatically pull the presets based on the chain name and type registry
+ ss58_format: the specific SS58 format to use
+ type_registry: a dict of custom types
+ chain_name: the name of the chain (the result of the rpc request for "system_chain")
+
"""
self.chain_endpoint = chain_endpoint
self.__chain = chain_name
- options = {
- "max_size": 2**32,
- "write_limit": 2**16,
- }
- if version.parse(websockets.__version__) < version.parse("14.0"):
- options.update({"read_limit": 2**16})
- self.ws = Websocket(chain_endpoint, options=options)
+ self.ws = Websocket(
+ chain_endpoint,
+ options={
+ "max_size": 2**32,
+ "write_limit": 2**16,
+ },
+ )
self._lock = asyncio.Lock()
self.last_block_hash: Optional[str] = None
self.config = {
"use_remote_preset": use_remote_preset,
"auto_discover": auto_discover,
- "auto_reconnect": auto_reconnect,
"rpc_methods": None,
"strict_scale_decode": True,
}
@@ -796,7 +816,7 @@ def __init__(
self.__metadata_cache = {}
self.type_registry_preset = None
self.transaction_version = None
- self.metadata = None
+ self.__metadata = None
self.metadata_version_hex = "0x0f000000" # v15
async def __aenter__(self):
@@ -825,10 +845,20 @@ def chain(self):
"""
return self.__chain
+ @property
+ def metadata(self):
+ if self.__metadata is None:
+ raise AttributeError(
+ "Metadata not found. This generally indicates that the AsyncSubstrateInterface object "
+ "is not properly async initialized."
+ )
+ else:
+ return self.__metadata
+
async def get_storage_item(self, module: str, storage_function: str):
- if not self.metadata:
+ if not self.__metadata:
await self.init_runtime()
- metadata_pallet = self.metadata.get_metadata_pallet(module)
+ metadata_pallet = self.__metadata.get_metadata_pallet(module)
storage_item = metadata_pallet.get_storage_function(storage_function)
return storage_item
@@ -853,23 +883,18 @@ async def load_registry(self):
metadata_v15 = MetadataV15.decode_from_metadata_option(metadata_option_bytes)
self.registry = PortableRegistry.from_metadata_v15(metadata_v15)
- async def decode_scale(
- self, type_string, scale_bytes: bytes, return_scale_obj=False
- ):
+ async def decode_scale(self, type_string, scale_bytes: bytes) -> Any:
"""
Helper function to decode arbitrary SCALE-bytes (e.g. 0x02000000) according to given RUST type_string
(e.g. BlockNumber). The relevant versioning information of the type (if defined) will be applied if block_hash
is set
- Parameters
- ----------
- type_string
- scale_bytes
- block_hash
- return_scale_obj: if True the SCALE object itself is returned, otherwise the serialized dict value of the object
+ Args:
+ type_string: the type string of the SCALE object for decoding
+ scale_bytes: the SCALE-bytes representation of the SCALE object to decode
- Returns
- -------
+ Returns:
+ Decoded object
"""
if scale_bytes == b"\x00":
@@ -889,21 +914,24 @@ async def init_runtime(
Because parsing of metadata and type registry is quite heavy, the result will be cached per runtime id.
In the future there could be support for caching backends like Redis to make this cache more persistent.
- :param block_hash: optional block hash, should not be specified if block_id is
- :param block_id: optional block id, should not be specified if block_hash is
+ Args:
+ block_hash: optional block hash, should not be specified if block_id is
+ block_id: optional block id, should not be specified if block_hash is
- :returns: Runtime object
+ Returns:
+ Runtime object
"""
async def get_runtime(block_hash, block_id) -> Runtime:
# Check if runtime state already set to current block
- if (block_hash and block_hash == self.last_block_hash) or (
- block_id and block_id == self.block_id
- ):
+ if (
+ (block_hash and block_hash == self.last_block_hash)
+ or (block_id and block_id == self.block_id)
+ ) and self.__metadata is not None:
return Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
)
@@ -945,39 +973,44 @@ async def get_runtime(block_hash, block_id) -> Runtime:
raise SubstrateRequestException(
f"No runtime information for block '{block_hash}'"
)
-
# Check if runtime state already set to current block
- if runtime_info.get("specVersion") == self.runtime_version:
+ if (
+ runtime_info.get("specVersion") == self.runtime_version
+ and self.__metadata is not None
+ ):
return Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
)
self.runtime_version = runtime_info.get("specVersion")
self.transaction_version = runtime_info.get("transactionVersion")
- if not self.metadata:
+ if not self.__metadata:
if self.runtime_version in self.__metadata_cache:
# Get metadata from cache
# self.debug_message('Retrieved metadata for {} from memory'.format(self.runtime_version))
- self.metadata = self.__metadata_cache[self.runtime_version]
+ metadata = self.__metadata = self.__metadata_cache[
+ self.runtime_version
+ ]
else:
- self.metadata = await self.get_block_metadata(
+ metadata = self.__metadata = await self.get_block_metadata(
block_hash=runtime_block_hash, decode=True
)
# self.debug_message('Retrieved metadata for {} from Substrate node'.format(self.runtime_version))
# Update metadata cache
- self.__metadata_cache[self.runtime_version] = self.metadata
-
+ self.__metadata_cache[self.runtime_version] = self.__metadata
+ else:
+ metadata = self.__metadata
# Update type registry
self.reload_type_registry(use_remote_preset=False, auto_discover=True)
if self.implements_scaleinfo:
# self.debug_message('Add PortableRegistry from metadata to type registry')
- self.runtime_config.add_portable_registry(self.metadata)
+ self.runtime_config.add_portable_registry(metadata)
# Set active runtime version
self.runtime_config.set_active_spec_version_id(self.runtime_version)
@@ -1005,14 +1038,17 @@ async def get_runtime(block_hash, block_id) -> Runtime:
return Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ metadata,
self.type_registry,
)
if block_id and block_hash:
raise ValueError("Cannot provide block_hash and block_id at the same time")
- if not (runtime := self.runtime_cache.retrieve(block_id, block_hash)):
+ if (
+ not (runtime := self.runtime_cache.retrieve(block_id, block_hash))
+ or runtime.metadata is None
+ ):
runtime = await get_runtime(block_hash, block_id)
self.runtime_cache.add_item(block_id, block_hash, runtime)
return runtime
@@ -1021,17 +1057,14 @@ def reload_type_registry(
self, use_remote_preset: bool = True, auto_discover: bool = True
):
"""
- Reload type registry and preset used to instantiate the SubtrateInterface object. Useful to periodically apply
- changes in type definitions when a runtime upgrade occurred
-
- Parameters
- ----------
- use_remote_preset: When True preset is downloaded from Github master, otherwise use files from local installed scalecodec package
- auto_discover
-
- Returns
- -------
+ Reload type registry and preset used to instantiate the `AsyncSubstrateInterface` object. Useful to
+ periodically apply changes in type definitions when a runtime upgrade occurred
+ Args:
+ use_remote_preset: When True preset is downloaded from Github master,
+ otherwise use files from local installed scalecodec package
+ auto_discover: Whether to automatically discover the type_registry
+ presets based on the chain name and typer registry
"""
self.runtime_config.clear_type_registry()
@@ -1098,8 +1131,8 @@ def implements_scaleinfo(self) -> Optional[bool]:
-------
bool
"""
- if self.metadata:
- return self.metadata.portable_registry is not None
+ if self.__metadata:
+ return self.__metadata.portable_registry is not None
else:
return None
@@ -1113,15 +1146,14 @@ async def create_storage_key(
"""
Create a `StorageKey` instance providing storage function details. See `subscribe_storage()`.
- Parameters
- ----------
- pallet: name of pallet
- storage_function: name of storage function
- params: Optional list of parameters in case of a Mapped storage function
+ Args:
+ pallet: name of pallet
+ storage_function: name of storage function
+ params: list of parameters in case of a Mapped storage function
+ block_hash: the hash of the blockchain block whose runtime to use
- Returns
- -------
- StorageKey
+ Returns:
+ StorageKey
"""
await self.init_runtime(block_hash=block_hash)
@@ -1130,7 +1162,7 @@ async def create_storage_key(
storage_function,
params,
runtime_config=self.runtime_config,
- metadata=self.metadata,
+ metadata=self.__metadata,
)
async def _get_block_handler(
@@ -1140,14 +1172,14 @@ async def _get_block_handler(
include_author: bool = False,
header_only: bool = False,
finalized_only: bool = False,
- subscription_handler: Optional[Callable] = None,
+ subscription_handler: Optional[Callable[[dict], Awaitable[Any]]] = None,
):
try:
await self.init_runtime(block_hash=block_hash)
except BlockNotFound:
return None
- async def decode_block(block_data, block_data_hash=None):
+ async def decode_block(block_data, block_data_hash=None) -> dict[str, Any]:
if block_data:
if block_data_hash:
block_data["header"]["hash"] = block_data_hash
@@ -1162,16 +1194,16 @@ async def decode_block(block_data, block_data_hash=None):
if "extrinsics" in block_data:
for idx, extrinsic_data in enumerate(block_data["extrinsics"]):
- extrinsic_decoder = extrinsic_cls(
- data=ScaleBytes(extrinsic_data),
- metadata=self.metadata,
- runtime_config=self.runtime_config,
- )
try:
+ extrinsic_decoder = extrinsic_cls(
+ data=ScaleBytes(extrinsic_data),
+ metadata=self.__metadata,
+ runtime_config=self.runtime_config,
+ )
extrinsic_decoder.decode(check_remaining=True)
block_data["extrinsics"][idx] = extrinsic_decoder
- except Exception as e:
+ except Exception:
if not ignore_decoding_errors:
raise
block_data["extrinsics"][idx] = None
@@ -1283,23 +1315,29 @@ async def decode_block(block_data, block_data_hash=None):
if callable(subscription_handler):
rpc_method_prefix = "Finalized" if finalized_only else "New"
- async def result_handler(message, update_nr, subscription_id):
- new_block = await decode_block({"header": message["params"]["result"]})
+ async def result_handler(
+ message: dict, subscription_id: str
+ ) -> tuple[Any, bool]:
+ reached = False
+ subscription_result = None
+ if "params" in message:
+ new_block = await decode_block(
+ {"header": message["params"]["result"]}
+ )
- subscription_result = subscription_handler(
- new_block, update_nr, subscription_id
- )
+ subscription_result = await subscription_handler(new_block)
- if subscription_result is not None:
- # Handler returned end result: unsubscribe from further updates
- self._forgettable_task = asyncio.create_task(
- self.rpc_request(
- f"chain_unsubscribe{rpc_method_prefix}Heads",
- [subscription_id],
+ if subscription_result is not None:
+ reached = True
+ # Handler returned end result: unsubscribe from further updates
+ self._forgettable_task = asyncio.create_task(
+ self.rpc_request(
+ f"chain_unsubscribe{rpc_method_prefix}Heads",
+ [subscription_id],
+ )
)
- )
- return subscription_result
+ return subscription_result, reached
result = await self._make_rpc_request(
[
@@ -1312,7 +1350,7 @@ async def result_handler(message, update_nr, subscription_id):
result_handler=result_handler,
)
- return result
+ return result["_get_block_handler"][-1]
else:
if header_only:
@@ -1341,17 +1379,15 @@ async def get_block(
Either `block_hash` or `block_number` should be set, or both omitted.
- Parameters
- ----------
- block_hash: the hash of the block to be retrieved
- block_number: the block number to retrieved
- ignore_decoding_errors: When set this will catch all decoding errors, set the item to None and continue decoding
- include_author: This will retrieve the block author from the validator set and add to the result
- finalized_only: when no `block_hash` or `block_number` is set, this will retrieve the finalized head
+ Args:
+ block_hash: the hash of the block to be retrieved
+ block_number: the block number to retrieved
+ ignore_decoding_errors: When set this will catch all decoding errors, set the item to None and continue decoding
+ include_author: This will retrieve the block author from the validator set and add to the result
+ finalized_only: when no `block_hash` or `block_number` is set, this will retrieve the finalized head
- Returns
- -------
- A dict containing the extrinsic and digest logs data
+ Returns:
+ A dict containing the extrinsic and digest logs data
"""
if block_hash and block_number:
raise ValueError("Either block_hash or block_number should be be set")
@@ -1385,13 +1421,11 @@ async def get_events(self, block_hash: Optional[str] = None) -> list:
"""
Convenience method to get events for a certain block (storage call for module 'System' and function 'Events')
- Parameters
- ----------
- block_hash
+ Args:
+ block_hash: the hash of the block to be retrieved
- Returns
- -------
- list
+ Returns:
+ list of events
"""
def convert_event_data(data):
@@ -1458,14 +1492,12 @@ async def get_block_metadata(
"""
A pass-though to existing JSONRPC method `state_getMetadata`.
- Parameters
- ----------
- block_hash
- decode: True for decoded version
-
- Returns
- -------
+ Args:
+ block_hash: the hash of the block to be queried against
+ decode: Whether to decode the metadata or present it raw
+ Returns:
+ metadata, either as a dict (not decoded) or ScaleType (decoded)
"""
params = None
if decode and not self.runtime_config:
@@ -1502,7 +1534,7 @@ async def _preprocess(
"""
params = query_for if query_for else []
# Search storage call in metadata
- metadata_pallet = self.metadata.get_metadata_pallet(module)
+ metadata_pallet = self.__metadata.get_metadata_pallet(module)
if not metadata_pallet:
raise SubstrateRequestException(f'Pallet "{module}" not found')
@@ -1528,7 +1560,7 @@ async def _preprocess(
storage_item.value["name"],
params,
runtime_config=self.runtime_config,
- metadata=self.metadata,
+ metadata=self.__metadata,
)
method = "state_getStorageAt"
return Preprocessed(
@@ -1552,14 +1584,16 @@ async def _process_response(
Processes the RPC call response by decoding it, returning it as is, or setting a handler for subscriptions,
depending on the specific call.
- :param response: the RPC call response
- :param subscription_id: the subscription id for subscriptions, used only for subscriptions with a result handler
- :param value_scale_type: Scale Type string used for decoding ScaleBytes results
- :param storage_item: The ScaleType object used for decoding ScaleBytes results
- :param runtime: the runtime object, used for decoding ScaleBytes results
- :param result_handler: the result handler coroutine used for handling longer-running subscriptions
+ Args:
+ response: the RPC call response
+ subscription_id: the subscription id for subscriptions, used only for subscriptions with a result handler
+ value_scale_type: Scale Type string used for decoding ScaleBytes results
+ storage_item: The ScaleType object used for decoding ScaleBytes results
+ runtime: the runtime object, used for decoding ScaleBytes results
+ result_handler: the result handler coroutine used for handling longer-running subscriptions
- :return: (decoded response, completion)
+ Returns:
+ (decoded response, completion)
"""
result: Union[dict, ScaleType] = response
if value_scale_type and isinstance(storage_item, ScaleType):
@@ -1568,7 +1602,7 @@ async def _process_response(
runtime = Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
)
if response.get("result") is not None:
@@ -1586,8 +1620,7 @@ async def _process_response(
q = bytes(query_value)
else:
q = query_value
- obj = await self.decode_scale(value_scale_type, q, True)
- result = obj
+ result = await self.decode_scale(value_scale_type, q)
if asyncio.iscoroutinefunction(result_handler):
# For multipart responses as a result of subscriptions.
message, bool_result = await result_handler(response, subscription_id)
@@ -1658,11 +1691,13 @@ def make_payload(id_: str, method: str, params: list) -> dict:
"""
Creates a payload for making an rpc_request with _make_rpc_request
- :param id_: a unique name you would like to give to this request
- :param method: the method in the RPC request
- :param params: the params in the RPC request
+ Args:
+ id_: a unique name you would like to give to this request
+ method: the method in the RPC request
+ params: the params in the RPC request
- :return: the payload dict
+ Returns:
+ the payload dict
"""
return {
"id": id_,
@@ -1677,17 +1712,19 @@ async def rpc_request(
reuse_block_hash: bool = False,
) -> Any:
"""
- Makes an RPC request to the subtensor. Use this only if ``self.query`` and ``self.query_multiple`` and
- ``self.query_map`` do not meet your needs.
+ Makes an RPC request to the subtensor. Use this only if `self.query`` and `self.query_multiple` and
+ `self.query_map` do not meet your needs.
- :param method: str the method in the RPC request
- :param params: list of the params in the RPC request
- :param block_hash: optional str, the hash of the block — only supply this if not supplying the block
- hash in the params, and not reusing the block hash
- :param reuse_block_hash: optional bool, whether to reuse the block hash in the params — only mark as True
- if not supplying the block hash in the params, or via the `block_hash` parameter
+ Args:
+ method: str the method in the RPC request
+ params: list of the params in the RPC request
+ block_hash: the hash of the block — only supply this if not supplying the block
+ hash in the params, and not reusing the block hash
+ reuse_block_hash: whether to reuse the block hash in the params — only mark as True
+ if not supplying the block hash in the params, or via the `block_hash` parameter
- :return: the response from the RPC request
+ Returns:
+ the response from the RPC request
"""
block_hash = await self._get_current_block_hash(block_hash, reuse_block_hash)
params = params or []
@@ -1702,7 +1739,7 @@ async def rpc_request(
runtime = Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
)
result = await self._make_rpc_request(payloads, runtime=runtime)
@@ -1728,7 +1765,7 @@ async def get_chain_head(self) -> str:
runtime=Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
),
)
@@ -1745,13 +1782,15 @@ async def compose_call(
"""
Composes a call payload which can be used in an extrinsic.
- :param call_module: Name of the runtime module e.g. Balances
- :param call_function: Name of the call function e.g. transfer
- :param call_params: This is a dict containing the params of the call. e.g.
- `{'dest': 'EaG2CRhJWPb7qmdcJvy3LiWdh26Jreu9Dx6R1rXxPmYXoDk', 'value': 1000000000000}`
- :param block_hash: Use metadata at given block_hash to compose call
+ Args:
+ call_module: Name of the runtime module e.g. Balances
+ call_function: Name of the call function e.g. transfer
+ call_params: This is a dict containing the params of the call. e.g.
+ `{'dest': 'EaG2CRhJWPb7qmdcJvy3LiWdh26Jreu9Dx6R1rXxPmYXoDk', 'value': 1000000000000}`
+ block_hash: Use metadata at given block_hash to compose call
- :return: A composed call
+ Returns:
+ A composed call
"""
if call_params is None:
call_params = {}
@@ -1759,7 +1798,7 @@ async def compose_call(
await self.init_runtime(block_hash=block_hash)
call = self.runtime_config.create_scale_object(
- type_string="Call", metadata=self.metadata
+ type_string="Call", metadata=self.__metadata
)
call.encode(
@@ -1832,14 +1871,12 @@ async def query_multi(
result = substrate.query_multi(storage_keys)
```
- Parameters
- ----------
- storage_keys: list of StorageKey objects
- block_hash: Optional block_hash of state snapshot
+ Args:
+ storage_keys: list of StorageKey objects
+ block_hash: hash of the block to query against
- Returns
- -------
- list of `(storage_key, scale_obj)` tuples
+ Returns:
+ list of `(storage_key, scale_obj)` tuples
"""
await self.init_runtime(block_hash=block_hash)
@@ -1886,12 +1923,14 @@ async def create_scale_object(
Convenience method to create a SCALE object of type `type_string`, this will initialize the runtime
automatically at moment of `block_hash`, or chain tip if omitted.
- :param type_string: str Name of SCALE type to create
- :param data: ScaleBytes Optional ScaleBytes to decode
- :param block_hash: Optional block hash for moment of decoding, when omitted the chain tip will be used
- :param kwargs: keyword args for the Scale Type constructor
+ Args:
+ type_string: Name of SCALE type to create
+ data: ScaleBytes: ScaleBytes to decode
+ block_hash: block hash for moment of decoding, when omitted the chain tip will be used
+ kwargs: keyword args for the Scale Type constructor
- :return: The created Scale Type object
+ Returns:
+ The created Scale Type object
"""
runtime = await self.init_runtime(block_hash=block_hash)
if "metadata" not in kwargs:
@@ -1939,12 +1978,12 @@ async def generate_signature_payload(
)
# Process signed extensions in metadata
- if "signed_extensions" in self.metadata[1][1]["extrinsic"]:
+ if "signed_extensions" in self.__metadata[1][1]["extrinsic"]:
# Base signature payload
signature_payload.type_mapping = [["call", "CallBytes"]]
# Add signed extensions to payload
- signed_extensions = self.metadata.get_signed_extensions()
+ signed_extensions = self.__metadata.get_signed_extensions()
if "CheckMortality" in signed_extensions:
signature_payload.type_mapping.append(
@@ -2064,16 +2103,18 @@ async def create_signed_extrinsic(
"""
Creates an extrinsic signed by given account details
- :param call: GenericCall to create extrinsic for
- :param keypair: Keypair used to sign the extrinsic
- :param era: Specify mortality in blocks in follow format:
- {'period': [amount_blocks]} If omitted the extrinsic is immortal
- :param nonce: nonce to include in extrinsics, if omitted the current nonce is retrieved on-chain
- :param tip: The tip for the block author to gain priority during network congestion
- :param tip_asset_id: Optional asset ID with which to pay the tip
- :param signature: Optionally provide signature if externally signed
+ Args:
+ call: GenericCall to create extrinsic for
+ keypair: Keypair used to sign the extrinsic
+ era: Specify mortality in blocks in follow format:
+ {'period': [amount_blocks]} If omitted the extrinsic is immortal
+ nonce: nonce to include in extrinsics, if omitted the current nonce is retrieved on-chain
+ tip: The tip for the block author to gain priority during network congestion
+ tip_asset_id: Optional asset ID with which to pay the tip
+ signature: Optionally provide signature if externally signed
- :return: The signed Extrinsic
+ Returns:
+ The signed Extrinsic
"""
await self.init_runtime()
@@ -2082,9 +2123,9 @@ async def create_signed_extrinsic(
raise TypeError("'call' must be of type Call")
# Check if extrinsic version is supported
- if self.metadata[1][1]["extrinsic"]["version"] != 4: # type: ignore
+ if self.__metadata[1][1]["extrinsic"]["version"] != 4: # type: ignore
raise NotImplementedError(
- f"Extrinsic version {self.metadata[1][1]['extrinsic']['version']} not supported" # type: ignore
+ f"Extrinsic version {self.__metadata[1][1]['extrinsic']['version']} not supported" # type: ignore
)
# Retrieve nonce
@@ -2126,7 +2167,7 @@ async def create_signed_extrinsic(
# Create extrinsic
extrinsic = self.runtime_config.create_scale_object(
- type_string="Extrinsic", metadata=self.metadata
+ type_string="Extrinsic", metadata=self.__metadata
)
value = {
@@ -2177,12 +2218,14 @@ async def runtime_call(
"""
Calls a runtime API method
- :param api: Name of the runtime API e.g. 'TransactionPaymentApi'
- :param method: Name of the method e.g. 'query_fee_details'
- :param params: List of parameters needed to call the runtime API
- :param block_hash: Hash of the block at which to make the runtime API call
+ Args:
+ api: Name of the runtime API e.g. 'TransactionPaymentApi'
+ method: Name of the method e.g. 'query_fee_details'
+ params: List of parameters needed to call the runtime API
+ block_hash: Hash of the block at which to make the runtime API call
- :return: ScaleType from the runtime call
+ Returns:
+ ScaleType from the runtime call
"""
await self.init_runtime()
@@ -2210,7 +2253,7 @@ async def runtime_call(
runtime = Runtime(
self.chain,
self.runtime_config,
- self.metadata,
+ self.__metadata,
self.type_registry,
)
@@ -2247,9 +2290,11 @@ async def get_account_nonce(self, account_address: str) -> int:
"""
Returns current nonce for given account address
- :param account_address: SS58 formatted address
+ Args:
+ account_address: SS58 formatted address
- :return: Nonce for given account address
+ Returns:
+ Nonce for given account address
"""
nonce_obj = await self.runtime_call(
"AccountNonceApi", "account_nonce", [account_address]
@@ -2261,20 +2306,18 @@ async def get_metadata_constant(self, module_name, constant_name, block_hash=Non
Retrieves the details of a constant for given module name, call function name and block_hash
(or chaintip if block_hash is omitted)
- Parameters
- ----------
- module_name
- constant_name
- block_hash
+ Args:
+ module_name: name of the module you are querying
+ constant_name: name of the constant you are querying
+ block_hash: hash of the block at which to make the runtime API call
- Returns
- -------
- MetadataModuleConstants
+ Returns:
+ MetadataModuleConstants
"""
- # await self.init_runtime(block_hash=block_hash)
+ await self.init_runtime(block_hash=block_hash)
- for module in self.metadata.pallets:
+ for module in self.__metadata.pallets:
if module_name == module.name and module.constants:
for constant in module.constants:
if constant_name == constant.value["name"]:
@@ -2286,19 +2329,19 @@ async def get_constant(
constant_name: str,
block_hash: Optional[str] = None,
reuse_block_hash: bool = False,
- ) -> "ScaleType":
+ ) -> Optional["ScaleType"]:
"""
Returns the decoded `ScaleType` object of the constant for given module name, call function name and block_hash
(or chaintip if block_hash is omitted)
- Parameters
- ----------
- :param module_name: Name of the module to query
- :param constant_name: Name of the constant to query
- :param block_hash: Hash of the block at which to make the runtime API call
- :param reuse_block_hash: Reuse last-used block hash if set to true
+ Args:
+ module_name: Name of the module to query
+ constant_name: Name of the constant to query
+ block_hash: Hash of the block at which to make the runtime API call
+ reuse_block_hash: Reuse last-used block hash if set to true
- :return: ScaleType from the runtime call
+ Returns:
+ ScaleType from the runtime call
"""
block_hash = await self._get_current_block_hash(block_hash, reuse_block_hash)
constant = await self.get_metadata_constant(
@@ -2309,7 +2352,6 @@ async def get_constant(
return await self.decode_scale(
constant.type,
bytes(constant.constant_value),
- return_scale_obj=True,
)
else:
return None
@@ -2320,16 +2362,14 @@ async def get_payment_info(
"""
Retrieves fee estimation via RPC for given extrinsic
- Parameters
- ----------
- call: Call object to estimate fees for
- keypair: Keypair of the sender, does not have to include private key because no valid signature is required
-
- Returns
- -------
- Dict with payment info
+ Args:
+ call: Call object to estimate fees for
+ keypair: Keypair of the sender, does not have to include private key because no valid signature is
+ required
- E.g. `{'class': 'normal', 'partialFee': 151000000, 'weight': {'ref_time': 143322000}}`
+ Returns:
+ Dict with payment info
+ E.g. `{'class': 'normal', 'partialFee': 151000000, 'weight': {'ref_time': 143322000}}`
"""
@@ -2365,7 +2405,7 @@ async def query(
raw_storage_key: Optional[bytes] = None,
subscription_handler=None,
reuse_block_hash: bool = False,
- ) -> Union["ScaleType"]:
+ ) -> "ScaleType":
"""
Queries subtensor. This should only be used when making a single request. For multiple requests,
you should use ``self.query_multiple``
@@ -2422,20 +2462,22 @@ async def query_map(
Note: it is important that you do not use `for x in result.records`, as this will sidestep possible
pagination. You must do `async for x in result`.
- :param module: The module name in the metadata, e.g. System or Balances.
- :param storage_function: The storage function name, e.g. Account or Locks.
- :param params: The input parameters in case of for example a `DoubleMap` storage function
- :param block_hash: Optional block hash for result at given block, when left to None the chain tip will be used.
- :param max_results: the maximum of results required, if set the query will stop fetching results when number is
- reached
- :param start_key: The storage key used as offset for the results, for pagination purposes
- :param page_size: The results are fetched from the node RPC in chunks of this size
- :param ignore_decoding_errors: When set this will catch all decoding errors, set the item to None and continue
- decoding
- :param reuse_block_hash: use True if you wish to make the query using the last-used block hash. Do not mark True
- if supplying a block_hash
-
- :return: QueryMapResult object
+ Args:
+ module: The module name in the metadata, e.g. System or Balances.
+ storage_function: The storage function name, e.g. Account or Locks.
+ params: The input parameters in case of for example a `DoubleMap` storage function
+ block_hash: Optional block hash for result at given block, when left to None the chain tip will be used.
+ max_results: the maximum of results required, if set the query will stop fetching results when number is
+ reached
+ start_key: The storage key used as offset for the results, for pagination purposes
+ page_size: The results are fetched from the node RPC in chunks of this size
+ ignore_decoding_errors: When set this will catch all decoding errors, set the item to None and continue
+ decoding
+ reuse_block_hash: use True if you wish to make the query using the last-used block hash. Do not mark True
+ if supplying a block_hash
+
+ Returns:
+ QueryMapResult object
"""
params = params or []
block_hash = await self._get_current_block_hash(block_hash, reuse_block_hash)
@@ -2534,7 +2576,6 @@ def concat_hash_len(key_hasher: str) -> int:
item_key_obj = await self.decode_scale(
type_string=f"({', '.join(key_type_string)})",
scale_bytes=bytes.fromhex(item[0][len(prefix) :]),
- return_scale_obj=True,
)
# strip key_hashers to use as item key
@@ -2552,15 +2593,10 @@ def concat_hash_len(key_hasher: str) -> int:
item_key = None
try:
- try:
- item_bytes = bytes.fromhex(item[1][2:])
- except ValueError:
- item_bytes = bytes.fromhex(item[1])
+ item_bytes = hex_to_bytes(item[1])
item_value = await self.decode_scale(
- type_string=value_type,
- scale_bytes=item_bytes,
- return_scale_obj=True,
+ type_string=value_type, scale_bytes=item_bytes
)
except Exception as _:
if not ignore_decoding_errors:
@@ -2593,16 +2629,13 @@ async def submit_extrinsic(
in a block and/or the block is finalized. The receipt returned provided information about the block and
triggered events
- Parameters
- ----------
- extrinsic: Extrinsic The extrinsic to be sent to the network
- wait_for_inclusion: wait until extrinsic is included in a block (only works for websocket connections)
- wait_for_finalization: wait until extrinsic is finalized (only works for websocket connections)
-
- Returns
- -------
- ExtrinsicReceipt
+ Args:
+ extrinsic: Extrinsic The extrinsic to be sent to the network
+ wait_for_inclusion: wait until extrinsic is included in a block (only works for websocket connections)
+ wait_for_finalization: wait until extrinsic is finalized (only works for websocket connections)
+ Returns:
+ ExtrinsicReceipt object of your submitted extrinsic
"""
# Check requirements
@@ -2615,11 +2648,13 @@ async def result_handler(message: dict, subscription_id) -> tuple[dict, bool]:
to handle the results of the extrinsic rpc call, which are multipart, and require
subscribing to the message
- :param message: message received from the rpc call
- :param subscription_id: subscription id received from the initial rpc call for the subscription
+ Args:
+ message: message received from the rpc call
+ subscription_id: subscription id received from the initial rpc call for the subscription
- :returns: tuple containing the dict of the block info for the subscription, and bool for whether
- the subscription is completed.
+ Returns:
+ tuple containing the dict of the block info for the subscription, and bool for whether
+ the subscription is completed.
"""
# Check if extrinsic is included and finalized
if "params" in message and isinstance(message["params"]["result"], dict):
@@ -2706,11 +2741,13 @@ async def get_metadata_call_function(
Retrieves a list of all call functions in metadata active for given block_hash (or chaintip if block_hash
is omitted)
- :param module_name: name of the module
- :param call_function_name: name of the call function
- :param block_hash: optional block hash
+ Args:
+ module_name: name of the module
+ call_function_name: name of the call function
+ block_hash: optional block hash
- :return: list of call functions
+ Returns:
+ list of call functions
"""
runtime = await self.init_runtime(block_hash=block_hash)
@@ -2721,7 +2758,7 @@ async def get_metadata_call_function(
return call
return None
- async def get_block_number(self, block_hash: Optional[str] = None) -> int:
+ async def get_block_number(self, block_hash: Optional[str]) -> int:
"""Async version of `substrateinterface.base.get_block_number` method."""
response = await self.rpc_request("chain_getHeader", [block_hash])
@@ -2740,3 +2777,49 @@ async def close(self):
await self.ws.shutdown()
except AttributeError:
pass
+
+ async def wait_for_block(
+ self,
+ block: int,
+ result_handler: Callable[[dict], Awaitable[Any]],
+ task_return: bool = True,
+ ) -> Union[asyncio.Task, Union[bool, Any]]:
+ """
+ Executes the result_handler when the chain has reached the block specified.
+
+ Args:
+ block: block number
+ result_handler: coroutine executed upon reaching the block number. This can be basically anything, but
+ must accept one single arg, a dict with the block data; whether you use this data or not is entirely
+ up to you.
+ task_return: True to immediately return the result of wait_for_block as an asyncio Task, False to wait
+ for the block to be reached, and return the result of the result handler.
+
+ Returns:
+ Either an asyncio.Task (which contains the running subscription, and whose `result()` will contain the
+ return of the result_handler), or the result itself, depending on `task_return` flag.
+ Note that if your result_handler returns `None`, this method will return `True`, otherwise
+ the return will be the result of your result_handler.
+ """
+
+ async def _handler(block_data: dict[str, Any]):
+ required_number = block
+ number = block_data["header"]["number"]
+ if number >= required_number:
+ return (
+ r if (r := await result_handler(block_data)) is not None else True
+ )
+
+ args = inspect.getfullargspec(result_handler).args
+ if len(args) != 1:
+ raise ValueError(
+ "result_handler must take exactly one arg: the dict block data."
+ )
+
+ co = self._get_block_handler(
+ self.last_block_hash, subscription_handler=_handler
+ )
+ if task_return is True:
+ return asyncio.create_task(co)
+ else:
+ return await co
diff --git a/bittensor/utils/balance.py b/bittensor/utils/balance.py
index 112036a95a..a22cdb8703 100644
--- a/bittensor/utils/balance.py
+++ b/bittensor/utils/balance.py
@@ -72,13 +72,13 @@ def __str__(self):
def __rich__(self):
int_tao, fract_tao = format(float(self.tao), "f").split(".")
- return f"{self.unit}{int_tao}.{fract_tao}"
+ return f"[green]{self.unit}{int_tao}.{fract_tao}[/green]"
def __str_rao__(self):
return f"{self.rao_unit}{int(self.rao)}"
def __rich_rao__(self):
- return f"{self.rao_unit}{int(self.rao)}"
+ return f"[green]{self.rao_unit}{int(self.rao)}[/green]"
def __repr__(self):
return self.__str__()
diff --git a/bittensor/utils/btlogging/console.py b/bittensor/utils/btlogging/console.py
new file mode 100644
index 0000000000..b169ac1be9
--- /dev/null
+++ b/bittensor/utils/btlogging/console.py
@@ -0,0 +1,72 @@
+"""
+BittensorConsole class gives the ability to log messages to the terminal without changing Bittensor logging level.
+
+Example:
+ from bittensor import logging
+
+ # will be logged
+ logging.console.info("info message")
+ logging.console.error("error message")
+ logging.console.success("success message")
+ logging.console.warning("warning message")
+ logging.console.critical("critical message")
+
+ # will not be logged
+ logging.info("test info")
+"""
+
+from typing import Callable, TYPE_CHECKING
+from functools import wraps
+from .helpers import all_loggers
+
+if TYPE_CHECKING:
+ from .loggingmachine import LoggingMachine
+
+
+def _print_wrapper(func: "Callable"):
+ @wraps(func)
+ def wrapper(self: "BittensorConsole", *args, **kwargs):
+ """A wrapper function to temporarily set the logger level to debug."""
+ old_logger_level = self.logger.get_level()
+ self.logger.set_console()
+ func(self, *args, **kwargs)
+
+ for logger in all_loggers():
+ logger.setLevel(old_logger_level)
+
+ return wrapper
+
+
+class BittensorConsole:
+ def __init__(self, logger: "LoggingMachine"):
+ self.logger = logger
+
+ @_print_wrapper
+ def debug(self, message: str):
+ """Logs a DEBUG message to the console."""
+ self.logger.debug(message)
+
+ @_print_wrapper
+ def info(self, message: str):
+ """Logs a INFO message to the console."""
+ self.logger.info(message)
+
+ @_print_wrapper
+ def success(self, message: str):
+ """Logs a SUCCESS message to the console."""
+ self.logger.success(message)
+
+ @_print_wrapper
+ def warning(self, message: str):
+ """Logs a WARNING message to the console."""
+ self.logger.warning(message)
+
+ @_print_wrapper
+ def error(self, message: str):
+ """Logs a ERROR message to the console."""
+ self.logger.error(message)
+
+ @_print_wrapper
+ def critical(self, message: str):
+ """Logs a CRITICAL message to the console."""
+ self.logger.critical(message)
diff --git a/bittensor/utils/btlogging/format.py b/bittensor/utils/btlogging/format.py
index 9e279a3b26..5f76dce6d4 100644
--- a/bittensor/utils/btlogging/format.py
+++ b/bittensor/utils/btlogging/format.py
@@ -26,7 +26,7 @@
from typing import Optional
from colorama import init, Fore, Back, Style
-init(autoreset=True)
+init(wrap=False)
TRACE_LEVEL_NUM: int = 5
SUCCESS_LEVEL_NUM: int = 21
@@ -56,18 +56,23 @@ def _success(self, message: str, *args, **kws):
":satellite:": "🛰️",
":warning:": "⚠️",
":arrow_right:": "➡️",
+ ":hourglass:": "⏳",
}
color_map: dict[str, str] = {
- "": Fore.RED,
- "": Style.RESET_ALL,
- "": Fore.BLUE,
- "": Style.RESET_ALL,
- "": Fore.GREEN,
- "": Style.RESET_ALL,
- "": Fore.MAGENTA,
- "": Style.RESET_ALL,
+ "[red]": Fore.RED,
+ "[/red]": Style.RESET_ALL,
+ "[blue]": Fore.BLUE,
+ "[/blue]": Style.RESET_ALL,
+ "[green]": Fore.GREEN,
+ "[/green]": Style.RESET_ALL,
+ "[magenta]": Fore.MAGENTA,
+ "[/magenta]": Style.RESET_ALL,
+ "[yellow]": Fore.YELLOW,
+ "[/yellow]": Style.RESET_ALL,
+ "[orange]": Fore.YELLOW,
+ "[/orange]": Style.RESET_ALL,
}
@@ -222,5 +227,5 @@ def format(self, record: "logging.LogRecord") -> str:
Returns:
formated record (str): The formatted log record.
"""
- record.levelname = f"{record.levelname:^16}"
+ record.levelname = f"{record.levelname:^10}"
return super().format(record)
diff --git a/bittensor/utils/btlogging/loggingmachine.py b/bittensor/utils/btlogging/loggingmachine.py
index 66d7cc7595..d4441054de 100644
--- a/bittensor/utils/btlogging/loggingmachine.py
+++ b/bittensor/utils/btlogging/loggingmachine.py
@@ -45,13 +45,21 @@
)
from .format import BtFileFormatter, BtStreamFormatter
from .helpers import all_loggers
+from bittensor.utils.btlogging.console import BittensorConsole
+
+# https://github.com/python/cpython/issues/97941
+CUSTOM_LOGGER_METHOD_STACK_LEVEL = 2 if sys.version_info >= (3, 11) else 1
def _concat_message(msg="", prefix="", suffix=""):
"""Concatenates a message with optional prefix and suffix."""
- empty_pref_suf = [None, ""]
- msg = f"{f'{prefix} - ' if prefix not in empty_pref_suf else ''}{msg}{f' - {suffix}' if suffix not in empty_pref_suf else ''}"
- return msg
+ message_parts = [
+ str(component).strip()
+ for component in [prefix, msg, suffix]
+ if component is not None and str(component).strip()
+ ]
+ formatted_message = " - ".join(message_parts)
+ return formatted_message
class LoggingConfig(NamedTuple):
@@ -80,6 +88,14 @@ class LoggingMachine(StateMachine, Logger):
| Warning.to(Default)
)
+ enable_console = (
+ Default.to(Debug)
+ | Trace.to(Debug)
+ | Disabled.to(Debug)
+ | Debug.to(Debug)
+ | Warning.to(Debug)
+ )
+
enable_info = enable_default
enable_trace = (
@@ -146,6 +162,7 @@ def __init__(self, config: "Config", name: str = BITTENSOR_LOGGER_NAME):
self._logger = self._initialize_bt_logger(name)
self.disable_third_party_loggers()
self._enable_initial_state(self._config)
+ self.console = BittensorConsole(self)
def _enable_initial_state(self, config):
"""Set correct state action on initializing"""
@@ -384,6 +401,12 @@ def before_enable_debug(self):
for logger in all_loggers():
logger.setLevel(stdlogging.DEBUG)
+ def before_enable_console(self):
+ """Logs status before enable Console."""
+ self._stream_formatter.set_trace(True)
+ for logger in all_loggers():
+ logger.setLevel(stdlogging.DEBUG)
+
def after_enable_debug(self):
"""Logs status after enable Debug."""
self._logger.info("Debug enabled.")
@@ -427,45 +450,55 @@ def __trace_on__(self) -> bool:
"""
return self.current_state_value == "Trace"
- def trace(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def trace(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps trace message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.trace(msg, *args, **kwargs)
+ self._logger.trace(
+ msg,
+ *args,
+ **kwargs,
+ stacklevel=stacklevel + CUSTOM_LOGGER_METHOD_STACK_LEVEL,
+ )
- def debug(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def debug(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps debug message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.debug(msg, *args, **kwargs)
+ self._logger.debug(msg, *args, **kwargs, stacklevel=stacklevel + 1)
- def info(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def info(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps info message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.info(msg, *args, **kwargs)
+ self._logger.info(msg, *args, **kwargs, stacklevel=stacklevel + 1)
- def success(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def success(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps success message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.success(msg, *args, **kwargs)
+ self._logger.success(
+ msg,
+ *args,
+ **kwargs,
+ stacklevel=stacklevel + CUSTOM_LOGGER_METHOD_STACK_LEVEL,
+ )
- def warning(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def warning(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps warning message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.warning(msg, *args, **kwargs)
+ self._logger.warning(msg, *args, **kwargs, stacklevel=stacklevel + 1)
- def error(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def error(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps error message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.error(msg, *args, **kwargs)
+ self._logger.error(msg, *args, **kwargs, stacklevel=stacklevel + 1)
- def critical(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def critical(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps critical message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.critical(msg, *args, **kwargs)
+ self._logger.critical(msg, *args, **kwargs, stacklevel=stacklevel + 1)
- def exception(self, msg="", prefix="", suffix="", *args, **kwargs):
+ def exception(self, msg="", prefix="", suffix="", *args, stacklevel=1, **kwargs):
"""Wraps exception message with prefix and suffix."""
msg = _concat_message(msg, prefix, suffix)
- self._logger.exception(msg, *args, **kwargs)
+ self._logger.exception(msg, *args, **kwargs, stacklevel=stacklevel + 1)
def on(self):
"""Enable default state."""
@@ -505,6 +538,11 @@ def set_default(self):
if not self.current_state_value == "Default":
self.enable_default()
+ def set_console(self):
+ """Sets Console state."""
+ if not self.current_state_value == "Console":
+ self.enable_console()
+
# as an option to be more obvious. `bittensor.logging.set_info()` is the same `bittensor.logging.set_default()`
def set_info(self):
"""Sets Default state."""
diff --git a/bittensor/utils/certifi.sh b/bittensor/utils/certifi.sh
new file mode 100755
index 0000000000..9dd4a68fe3
--- /dev/null
+++ b/bittensor/utils/certifi.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Locate Python 3
+PYTHON=$(command -v python3)
+if [ -z "$PYTHON" ]; then
+ echo "Error: Python 3 is not installed or not found in PATH."
+ exit 1
+fi
+
+echo "Using Python: $PYTHON"
+
+echo " -- Upgrading the certifi package"
+$PYTHON -m pip install --upgrade certifi
+
+echo " -- Fetching the path to the certifi certificate bundle"
+CERTIFI_CAFILE=$($PYTHON -c "import certifi; print(certifi.where())")
+
+echo " -- Resolving OpenSSL directory and certificate file path"
+OPENSSL_DIR=$($PYTHON -c "import ssl; print(ssl.get_default_verify_paths().openssl_cafile.rsplit('/', 1)[0])")
+OPENSSL_CAFILE=$($PYTHON -c "import ssl; print(ssl.get_default_verify_paths().openssl_cafile.rsplit('/', 1)[-1])")
+
+echo " -- Navigating to the OpenSSL directory"
+cd "$OPENSSL_DIR" || { echo "Failed to navigate to $OPENSSL_DIR"; exit 1; }
+
+echo " -- Removing any existing certificate file or symlink"
+rm -f "$OPENSSL_CAFILE"
+
+echo " -- Creating a symlink to the certifi certificate bundle"
+ln -s "$CERTIFI_CAFILE" "$OPENSSL_CAFILE"
+
+echo " -- Setting appropriate file permissions"
+chmod 775 "$OPENSSL_CAFILE"
+
+echo " -- Update complete"
diff --git a/bittensor/utils/mock/subtensor_mock.py b/bittensor/utils/mock/subtensor_mock.py
index 817be08434..22eb023896 100644
--- a/bittensor/utils/mock/subtensor_mock.py
+++ b/bittensor/utils/mock/subtensor_mock.py
@@ -20,9 +20,11 @@
from hashlib import sha256
from types import SimpleNamespace
from typing import Any, Optional, Union, TypedDict
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
from bittensor_wallet import Wallet
+from substrateinterface.base import SubstrateInterface
+from websockets.sync.client import ClientConnection
from bittensor.core.chain_data import (
NeuronInfo,
@@ -30,8 +32,10 @@
PrometheusInfo,
AxonInfo,
)
+from bittensor.core.types import AxonServeCallParams, PrometheusServeCallParams
from bittensor.core.errors import ChainQueryError
from bittensor.core.subtensor import Subtensor
+import bittensor.core.subtensor as subtensor_module
from bittensor.utils import RAOPERTAO, u16_normalized_float
from bittensor.utils.balance import Balance
@@ -39,26 +43,6 @@
__GLOBAL_MOCK_STATE__ = {}
-class AxonServeCallParams(TypedDict):
- """Axon serve chain call parameters."""
-
- version: int
- ip: int
- port: int
- ip_type: int
- netuid: int
-
-
-class PrometheusServeCallParams(TypedDict):
- """Prometheus serve chain call parameters."""
-
- version: int
- ip: int
- port: int
- ip_type: int
- netuid: int
-
-
BlockNumber = int
@@ -267,14 +251,22 @@ def setup(self) -> None:
self.network = "mock"
self.chain_endpoint = "ws://mock_endpoint.bt"
- self.substrate = MagicMock()
+ self.substrate = MagicMock(autospec=SubstrateInterface)
def __init__(self, *args, **kwargs) -> None:
- super().__init__()
- self.__dict__ = __GLOBAL_MOCK_STATE__
-
- if not hasattr(self, "chain_state") or getattr(self, "chain_state") is None:
- self.setup()
+ mock_substrate_interface = MagicMock(autospec=SubstrateInterface)
+ mock_websocket = MagicMock(autospec=ClientConnection)
+ mock_websocket.close_code = None
+ with patch.object(
+ subtensor_module,
+ "SubstrateInterface",
+ return_value=mock_substrate_interface,
+ ):
+ super().__init__(websocket=mock_websocket)
+ self.__dict__ = __GLOBAL_MOCK_STATE__
+
+ if not hasattr(self, "chain_state") or getattr(self, "chain_state") is None:
+ self.setup()
def get_block_hash(self, block_id: int) -> str:
return "0x" + sha256(str(block_id).encode()).hexdigest()[:64]
@@ -460,8 +452,10 @@ def query_subtensor(
self,
name: str,
block: Optional[int] = None,
- params: Optional[list[object]] = [],
+ params: Optional[list[object]] = None,
) -> MockSubtensorValue:
+ if params is None:
+ params = []
if block:
if self.block_number < block:
raise Exception("Cannot query block in the future")
@@ -496,11 +490,13 @@ def query_map_subtensor(
self,
name: str,
block: Optional[int] = None,
- params: Optional[list[object]] = [],
+ params: Optional[list[object]] = None,
) -> Optional[MockMapResult]:
"""
Note: Double map requires one param
"""
+ if params is None:
+ params = []
if block:
if self.block_number < block:
raise Exception("Cannot query block in the future")
@@ -554,7 +550,7 @@ def query_constant(
else:
block = self.block_number
- state = self.chain_state.get(module_name, None)
+ state: Optional[dict] = self.chain_state.get(module_name, None)
if state is not None:
if constant_name in state:
state = state[constant_name]
@@ -831,6 +827,52 @@ def neurons_lite(
return neurons
+ def neuron_for_uid_lite(
+ self, uid: int, netuid: int, block: Optional[int] = None
+ ) -> Optional[NeuronInfoLite]:
+ if uid is None:
+ return NeuronInfoLite.get_null_neuron()
+
+ if block:
+ if self.block_number < block:
+ raise Exception("Cannot query block in the future")
+
+ else:
+ block = self.block_number
+
+ if netuid not in self.chain_state["SubtensorModule"]["NetworksAdded"]:
+ return None
+
+ neuron_info = self._neuron_subnet_exists(uid, netuid, block)
+ if neuron_info is None:
+ # TODO Why does this return None here but a null neuron earlier?
+ return None
+
+ else:
+ return NeuronInfoLite(
+ hotkey=neuron_info.hotkey,
+ coldkey=neuron_info.coldkey,
+ uid=neuron_info.uid,
+ netuid=neuron_info.netuid,
+ active=neuron_info.active,
+ stake=neuron_info.stake,
+ stake_dict=neuron_info.stake_dict,
+ total_stake=neuron_info.total_stake,
+ rank=neuron_info.rank,
+ emission=neuron_info.emission,
+ incentive=neuron_info.incentive,
+ consensus=neuron_info.consensus,
+ trust=neuron_info.trust,
+ validator_trust=neuron_info.validator_trust,
+ dividends=neuron_info.dividends,
+ last_update=neuron_info.last_update,
+ validator_permit=neuron_info.validator_permit,
+ prometheus_info=neuron_info.prometheus_info,
+ axon_info=neuron_info.axon_info,
+ pruning_score=neuron_info.pruning_score,
+ is_null=neuron_info.is_null,
+ )
+
def get_transfer_fee(
self, wallet: "Wallet", dest: str, value: Union["Balance", float, int]
) -> "Balance":
diff --git a/bittensor/utils/networking.py b/bittensor/utils/networking.py
index 76686d5fa4..f47c88512e 100644
--- a/bittensor/utils/networking.py
+++ b/bittensor/utils/networking.py
@@ -1,20 +1,3 @@
-# The MIT License (MIT)
-# Copyright © 2024 Opentensor Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-# the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
"""Utils for handling local network with ip and ports."""
import json
@@ -26,6 +9,8 @@
import netaddr
import requests
+from retry import retry
+from websockets.exceptions import ConnectionClosed
from bittensor.utils.btlogging import logging
@@ -178,22 +163,45 @@ def get_formatted_ws_endpoint_url(endpoint_url: Optional[str]) -> Optional[str]:
def ensure_connected(func):
"""Decorator ensuring the function executes with an active substrate connection."""
+ def is_connected(substrate) -> bool:
+ """Check if the substrate connection is active."""
+ sock = substrate.websocket.socket
+ return (
+ sock is not None
+ and sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) == 0
+ )
+
+ @retry(
+ exceptions=ConnectionRefusedError,
+ tries=5,
+ delay=5,
+ backoff=1,
+ logger=logging,
+ )
+ def reconnect_with_retries(self):
+ """Attempt to reconnect with retries using retry library."""
+ logging.console.info("Attempting to reconnect to substrate...")
+ self._get_substrate()
+ logging.console.success("Connection successfully restored!")
+
@wraps(func)
def wrapper(self, *args, **kwargs):
- """Wrapper function where `self` argument is Subtensor instance with the substrate connection."""
- # Check the socket state before method execution
- if (
- # connection was closed correctly
- self.substrate.websocket.sock is None
- # connection has a broken pipe
- or self.substrate.websocket.sock.getsockopt(
- socket.SOL_SOCKET, socket.SO_ERROR
- )
- != 0
- ):
- logging.debug("Reconnecting to substrate...")
+ """Wrapper function where `self` is expected to be a Subtensor instance."""
+ if not is_connected(self.substrate):
+ logging.debug("Substrate connection inactive. Attempting to reconnect...")
self._get_substrate()
- # Execute the method if the connection is active or after reconnecting
- return func(self, *args, **kwargs)
+
+ try:
+ return func(self, *args, **kwargs)
+ except ConnectionClosed:
+ logging.console.warning(
+ "WebSocket connection closed. Attempting to reconnect 5 times..."
+ )
+ try:
+ reconnect_with_retries(self)
+ return func(self, *args, **kwargs)
+ except ConnectionRefusedError:
+ logging.critical("Unable to restore connection. Raising exception.")
+ raise ConnectionRefusedError("Failed to reconnect to substrate.")
return wrapper
diff --git a/bittensor/utils/registration.py b/bittensor/utils/registration.py
index f190f668da..e69de29bb2 100644
--- a/bittensor/utils/registration.py
+++ b/bittensor/utils/registration.py
@@ -1,1120 +0,0 @@
-# The MIT License (MIT)
-# Copyright © 2024 Opentensor Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-# the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-import binascii
-import dataclasses
-import functools
-import hashlib
-import math
-import multiprocessing
-import os
-import random
-import subprocess
-import time
-from datetime import timedelta
-from multiprocessing.queues import Queue as QueueType
-from queue import Empty, Full
-from typing import Any, Callable, Optional, Union, TYPE_CHECKING
-
-import numpy
-from Crypto.Hash import keccak
-from retry import retry
-from rich import console as rich_console, status as rich_status
-from rich.console import Console
-
-from bittensor.utils.btlogging import logging
-from bittensor.utils.formatting import get_human_readable, millify
-from bittensor.utils.register_cuda import solve_cuda
-
-
-def use_torch() -> bool:
- """Force the use of torch over numpy for certain operations."""
- return True if os.getenv("USE_TORCH") == "1" else False
-
-
-def legacy_torch_api_compat(func):
- """
- Convert function operating on numpy Input&Output to legacy torch Input&Output API if `use_torch()` is True.
-
- Args:
- func (function): Function with numpy Input/Output to be decorated.
-
- Returns:
- decorated (function): Decorated function.
- """
-
- @functools.wraps(func)
- def decorated(*args, **kwargs):
- if use_torch():
- # if argument is a Torch tensor, convert it to numpy
- args = [
- arg.cpu().numpy() if isinstance(arg, torch.Tensor) else arg
- for arg in args
- ]
- kwargs = {
- key: value.cpu().numpy() if isinstance(value, torch.Tensor) else value
- for key, value in kwargs.items()
- }
- ret = func(*args, **kwargs)
- if use_torch():
- # if return value is a numpy array, convert it to Torch tensor
- if isinstance(ret, numpy.ndarray):
- ret = torch.from_numpy(ret)
- return ret
-
- return decorated
-
-
-@functools.cache
-def _get_real_torch():
- try:
- import torch as _real_torch
- except ImportError:
- _real_torch = None
- return _real_torch
-
-
-def log_no_torch_error():
- logging.error(
- "This command requires torch. You can install torch for bittensor"
- ' with `pip install bittensor[torch]` or `pip install ".[torch]"`'
- " if installing from source, and then run the command with USE_TORCH=1 {command}"
- )
-
-
-class LazyLoadedTorch:
- """A lazy-loading proxy for the torch module."""
-
- def __bool__(self):
- return bool(_get_real_torch())
-
- def __getattr__(self, name):
- if real_torch := _get_real_torch():
- return getattr(real_torch, name)
- else:
- log_no_torch_error()
- raise ImportError("torch not installed")
-
-
-if TYPE_CHECKING:
- import torch
- from bittensor.core.subtensor import Subtensor
- from bittensor_wallet import Wallet
-else:
- torch = LazyLoadedTorch()
-
-
-def _hex_bytes_to_u8_list(hex_bytes: bytes):
- hex_chunks = [int(hex_bytes[i : i + 2], 16) for i in range(0, len(hex_bytes), 2)]
- return hex_chunks
-
-
-def _create_seal_hash(block_and_hotkey_hash_bytes: bytes, nonce: int) -> bytes:
- """Create a seal hash for a given block and nonce."""
- nonce_bytes = binascii.hexlify(nonce.to_bytes(8, "little"))
- pre_seal = nonce_bytes + binascii.hexlify(block_and_hotkey_hash_bytes)[:64]
- seal_sh256 = hashlib.sha256(bytearray(_hex_bytes_to_u8_list(pre_seal))).digest()
- kec = keccak.new(digest_bits=256)
- seal = kec.update(seal_sh256).digest()
- return seal
-
-
-def _seal_meets_difficulty(seal: bytes, difficulty: int, limit: int):
- """Check if the seal meets the given difficulty criteria."""
- seal_number = int.from_bytes(seal, "big")
- product = seal_number * difficulty
- return product < limit
-
-
-@dataclasses.dataclass
-class POWSolution:
- """A solution to the registration PoW problem."""
-
- nonce: int
- block_number: int
- difficulty: int
- seal: bytes
-
- def is_stale(self, subtensor: "Subtensor") -> bool:
- """
- Returns True if the POW is stale.
-
- This means the block the POW is solved for is within 3 blocks of the current block.
- """
- return self.block_number < subtensor.get_current_block() - 3
-
-
-class _UsingSpawnStartMethod:
- def __init__(self, force: bool = False):
- self._old_start_method = None
- self._force = force
-
- def __enter__(self):
- self._old_start_method = multiprocessing.get_start_method(allow_none=True)
- if self._old_start_method is None:
- self._old_start_method = "spawn" # default to spawn
-
- multiprocessing.set_start_method("spawn", force=self._force)
-
- def __exit__(self, *args):
- # restore the old start method
- multiprocessing.set_start_method(self._old_start_method, force=True)
-
-
-class _SolverBase(multiprocessing.Process):
- """
- A process that solves the registration PoW problem.
-
- Args:
- proc_num (int): The number of the process being created.
- num_proc (int): The total number of processes running.
- update_interval (int): The number of nonces to try to solve before checking for a new block.
- finished_queue (multiprocessing.Queue): The queue to put the process number when a process finishes each update_interval. Used for calculating the average time per update_interval across all processes.
- solution_queue (multiprocessing.Queue): The queue to put the solution the process has found during the pow solve.
- newBlockEvent (multiprocessing.Event): The event to set by the main process when a new block is finalized in the network. The solver process will check for the event after each update_interval. The solver process will get the new block hash and difficulty and start solving for a new nonce.
- stopEvent (multiprocessing.Event): The event to set by the main process when all the solver processes should stop. The solver process will check for the event after each update_interval. The solver process will stop when the event is set. Used to stop the solver processes when a solution is found.
- curr_block (multiprocessing.Array): The array containing this process's current block hash. The main process will set the array to the new block hash when a new block is finalized in the network. The solver process will get the new block hash from this array when newBlockEvent is set.
- curr_block_num (multiprocessing.Value): The value containing this process's current block number. The main process will set the value to the new block number when a new block is finalized in the network. The solver process will get the new block number from this value when newBlockEvent is set.
- curr_diff (multiprocessing.Array): The array containing this process's current difficulty. The main process will set the array to the new difficulty when a new block is finalized in the network. The solver process will get the new difficulty from this array when newBlockEvent is set.
- check_block (multiprocessing.Lock): The lock to prevent this process from getting the new block data while the main process is updating the data.
- limit (int): The limit of the pow solve for a valid solution.
- """
-
- proc_num: int
- num_proc: int
- update_interval: int
- finished_queue: "multiprocessing.Queue"
- solution_queue: "multiprocessing.Queue"
- newBlockEvent: "multiprocessing.Event"
- stopEvent: "multiprocessing.Event"
- hotkey_bytes: bytes
- curr_block: "multiprocessing.Array"
- curr_block_num: "multiprocessing.Value"
- curr_diff: "multiprocessing.Array"
- check_block: "multiprocessing.Lock"
- limit: int
-
- def __init__(
- self,
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stopEvent,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- ):
- multiprocessing.Process.__init__(self, daemon=True)
- self.proc_num = proc_num
- self.num_proc = num_proc
- self.update_interval = update_interval
- self.finished_queue = finished_queue
- self.solution_queue = solution_queue
- self.newBlockEvent = multiprocessing.Event()
- self.newBlockEvent.clear()
- self.curr_block = curr_block
- self.curr_block_num = curr_block_num
- self.curr_diff = curr_diff
- self.check_block = check_block
- self.stopEvent = stopEvent
- self.limit = limit
-
- def run(self):
- raise NotImplementedError("_SolverBase is an abstract class")
-
- @staticmethod
- def create_shared_memory() -> (
- tuple["multiprocessing.Array", "multiprocessing.Value", "multiprocessing.Array"]
- ):
- """Creates shared memory for the solver processes to use."""
- curr_block = multiprocessing.Array("h", 32, lock=True) # byte array
- curr_block_num = multiprocessing.Value("i", 0, lock=True) # int
- curr_diff = multiprocessing.Array("Q", [0, 0], lock=True) # [high, low]
-
- return curr_block, curr_block_num, curr_diff
-
-
-class _Solver(_SolverBase):
- def run(self):
- block_number: int
- block_and_hotkey_hash_bytes: bytes
- block_difficulty: int
- nonce_limit = int(math.pow(2, 64)) - 1
-
- # Start at random nonce
- nonce_start = random.randint(0, nonce_limit)
- nonce_end = nonce_start + self.update_interval
- while not self.stopEvent.is_set():
- if self.newBlockEvent.is_set():
- with self.check_block:
- block_number = self.curr_block_num.value
- block_and_hotkey_hash_bytes = bytes(self.curr_block)
- block_difficulty = _registration_diff_unpack(self.curr_diff)
-
- self.newBlockEvent.clear()
-
- # Do a block of nonces
- solution = _solve_for_nonce_block(
- nonce_start,
- nonce_end,
- block_and_hotkey_hash_bytes,
- block_difficulty,
- self.limit,
- block_number,
- )
- if solution is not None:
- self.solution_queue.put(solution)
-
- try:
- # Send time
- self.finished_queue.put_nowait(self.proc_num)
- except Full:
- pass
-
- nonce_start = random.randint(0, nonce_limit)
- nonce_start = nonce_start % nonce_limit
- nonce_end = nonce_start + self.update_interval
-
-
-class _CUDASolver(_SolverBase):
- dev_id: int
- tpb: int
-
- def __init__(
- self,
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stopEvent,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- dev_id: int,
- tpb: int,
- ):
- super().__init__(
- proc_num,
- num_proc,
- update_interval,
- finished_queue,
- solution_queue,
- stopEvent,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- )
- self.dev_id = dev_id
- self.tpb = tpb
-
- def run(self):
- block_number: int = 0 # dummy value
- block_and_hotkey_hash_bytes: bytes = b"0" * 32 # dummy value
- block_difficulty: int = int(math.pow(2, 64)) - 1 # dummy value
- nonce_limit = int(math.pow(2, 64)) - 1 # U64MAX
-
- # Start at random nonce
- nonce_start = random.randint(0, nonce_limit)
- while not self.stopEvent.is_set():
- if self.newBlockEvent.is_set():
- with self.check_block:
- block_number = self.curr_block_num.value
- block_and_hotkey_hash_bytes = bytes(self.curr_block)
- block_difficulty = _registration_diff_unpack(self.curr_diff)
-
- self.newBlockEvent.clear()
-
- # Do a block of nonces
- solution = _solve_for_nonce_block_cuda(
- nonce_start,
- self.update_interval,
- block_and_hotkey_hash_bytes,
- block_difficulty,
- self.limit,
- block_number,
- self.dev_id,
- self.tpb,
- )
- if solution is not None:
- self.solution_queue.put(solution)
-
- try:
- # Signal that a nonce_block was finished using queue
- # send our proc_num
- self.finished_queue.put(self.proc_num)
- except Full:
- pass
-
- # increase nonce by number of nonces processed
- nonce_start += self.update_interval * self.tpb
- nonce_start = nonce_start % nonce_limit
-
-
-def _solve_for_nonce_block_cuda(
- nonce_start: int,
- update_interval: int,
- block_and_hotkey_hash_bytes: bytes,
- difficulty: int,
- limit: int,
- block_number: int,
- dev_id: int,
- tpb: int,
-) -> Optional["POWSolution"]:
- """Tries to solve the POW on a CUDA device for a block of nonces (nonce_start, nonce_start + update_interval * tpb"""
- solution, seal = solve_cuda(
- nonce_start,
- update_interval,
- tpb,
- block_and_hotkey_hash_bytes,
- difficulty,
- limit,
- dev_id,
- )
-
- if solution != -1:
- # Check if solution is valid (i.e. not -1)
- return POWSolution(solution, block_number, difficulty, seal)
-
- return None
-
-
-def _solve_for_nonce_block(
- nonce_start: int,
- nonce_end: int,
- block_and_hotkey_hash_bytes: bytes,
- difficulty: int,
- limit: int,
- block_number: int,
-) -> Optional["POWSolution"]:
- """Tries to solve the POW for a block of nonces (nonce_start, nonce_end)"""
- for nonce in range(nonce_start, nonce_end):
- # Create seal.
- seal = _create_seal_hash(block_and_hotkey_hash_bytes, nonce)
-
- # Check if seal meets difficulty
- if _seal_meets_difficulty(seal, difficulty, limit):
- # Found a solution, save it.
- return POWSolution(nonce, block_number, difficulty, seal)
-
- return None
-
-
-def _registration_diff_unpack(packed_diff: "multiprocessing.Array") -> int:
- """Unpacks the packed two 32-bit integers into one 64-bit integer. Little endian."""
- return int(packed_diff[0] << 32 | packed_diff[1])
-
-
-def _registration_diff_pack(diff: int, packed_diff: "multiprocessing.Array"):
- """Packs the difficulty into two 32-bit integers. Little endian."""
- packed_diff[0] = diff >> 32
- packed_diff[1] = diff & 0xFFFFFFFF # low 32 bits
-
-
-def _hash_block_with_hotkey(block_bytes: bytes, hotkey_bytes: bytes) -> bytes:
- """Hashes the block with the hotkey using Keccak-256 to get 32 bytes"""
- kec = keccak.new(digest_bits=256)
- kec = kec.update(bytearray(block_bytes + hotkey_bytes))
- block_and_hotkey_hash_bytes = kec.digest()
- return block_and_hotkey_hash_bytes
-
-
-def _update_curr_block(
- curr_diff: "multiprocessing.Array",
- curr_block: "multiprocessing.Array",
- curr_block_num: "multiprocessing.Value",
- block_number: int,
- block_bytes: bytes,
- diff: int,
- hotkey_bytes: bytes,
- lock: "multiprocessing.Lock",
-):
- """Updates the current block's information atomically using a lock."""
- with lock:
- curr_block_num.value = block_number
- # Hash the block with the hotkey
- block_and_hotkey_hash_bytes = _hash_block_with_hotkey(block_bytes, hotkey_bytes)
- for i in range(32):
- curr_block[i] = block_and_hotkey_hash_bytes[i]
- _registration_diff_pack(diff, curr_diff)
-
-
-def get_cpu_count() -> int:
- """Returns the number of CPUs in the system."""
- try:
- return len(os.sched_getaffinity(0))
- except AttributeError:
- # OSX does not have sched_getaffinity
- return os.cpu_count()
-
-
-@dataclasses.dataclass
-class RegistrationStatistics:
- """Statistics for a registration."""
-
- time_spent_total: float
- rounds_total: int
- time_average: float
- time_spent: float
- hash_rate_perpetual: float
- hash_rate: float
- difficulty: int
- block_number: int
- block_hash: bytes
-
-
-class RegistrationStatisticsLogger:
- """Logs statistics for a registration."""
-
- status: Optional[rich_status.Status]
-
- def __init__(
- self,
- console: Optional[rich_console.Console] = None,
- output_in_place: bool = True,
- ) -> None:
- if console is None:
- console = Console()
-
- self.console = console
-
- if output_in_place:
- self.status = self.console.status("Solving")
- else:
- self.status = None
-
- def start(self) -> None:
- if self.status is not None:
- self.status.start()
-
- def stop(self) -> None:
- if self.status is not None:
- self.status.stop()
-
- def get_status_message(
- self, stats: RegistrationStatistics, verbose: bool = False
- ) -> str:
- """Generates the status message based on registration statistics."""
- message = (
- "Solving\n"
- + f"Time Spent (total): [bold white]{timedelta(seconds=stats.time_spent_total)}[/bold white]\n"
- + (
- f"Time Spent This Round: {timedelta(seconds=stats.time_spent)}\n"
- + f"Time Spent Average: {timedelta(seconds=stats.time_average)}\n"
- if verbose
- else ""
- )
- + f"Registration Difficulty: [bold white]{millify(stats.difficulty)}[/bold white]\n"
- + f"Iters (Inst/Perp): [bold white]{get_human_readable(stats.hash_rate, 'H')}/s / "
- + f"{get_human_readable(stats.hash_rate_perpetual, 'H')}/s[/bold white]\n"
- + f"Block Number: [bold white]{stats.block_number}[/bold white]\n"
- + f"Block Hash: [bold white]{stats.block_hash.encode('utf-8')}[/bold white]\n"
- )
- return message
-
- def update(self, stats: RegistrationStatistics, verbose: bool = False) -> None:
- if self.status is not None:
- self.status.update(self.get_status_message(stats, verbose=verbose))
- else:
- self.console.log(self.get_status_message(stats, verbose=verbose))
-
-
-def _solve_for_difficulty_fast(
- subtensor: "Subtensor",
- wallet: "Wallet",
- netuid: int,
- output_in_place: bool = True,
- num_processes: Optional[int] = None,
- update_interval: Optional[int] = None,
- n_samples: int = 10,
- alpha_: float = 0.80,
- log_verbose: bool = False,
-) -> Optional[POWSolution]:
- """
- Solves the POW for registration using multiprocessing.
-
- Args:
- subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance to connect to for block information and to submit.
- wallet (bittensor_wallet.Wallet): wallet to use for registration.
- netuid (int): The netuid of the subnet to register to.
- output_in_place (bool): If true, prints the status in place. Otherwise, prints the status on a new line.
- num_processes (int): Number of processes to use.
- update_interval (int): Number of nonces to solve before updating block information.
- n_samples (int): The number of samples of the hash_rate to keep for the EWMA.
- alpha_ (float): The alpha for the EWMA for the hash_rate calculation.
- log_verbose (bool): If true, prints more verbose logging of the registration metrics.
-
- Note: The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
- Note: We can also modify the update interval to do smaller blocks of work, while still updating the block information after a different number of nonces, to increase the transparency of the process while still keeping the speed.
- """
- if num_processes is None:
- # get the number of allowed processes for this process
- num_processes = min(1, get_cpu_count())
-
- if update_interval is None:
- update_interval = 50_000
-
- limit = int(math.pow(2, 256)) - 1
-
- curr_block, curr_block_num, curr_diff = _Solver.create_shared_memory()
-
- # Establish communication queues
- # See the _Solver class for more information on the queues.
- stopEvent = multiprocessing.Event()
- stopEvent.clear()
-
- solution_queue = multiprocessing.Queue()
- finished_queues = [multiprocessing.Queue() for _ in range(num_processes)]
- check_block = multiprocessing.Lock()
-
- hotkey_bytes = (
- wallet.coldkeypub.public_key if netuid == -1 else wallet.hotkey.public_key
- )
- # Start consumers
- solvers = [
- _Solver(
- i,
- num_processes,
- update_interval,
- finished_queues[i],
- solution_queue,
- stopEvent,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- )
- for i in range(num_processes)
- ]
-
- # Get first block
- block_number, difficulty, block_hash = _get_block_with_retry(
- subtensor=subtensor, netuid=netuid
- )
-
- block_bytes = bytes.fromhex(block_hash[2:])
- old_block_number = block_number
- # Set to current block
- _update_curr_block(
- curr_diff,
- curr_block,
- curr_block_num,
- block_number,
- block_bytes,
- difficulty,
- hotkey_bytes,
- check_block,
- )
-
- # Set new block events for each solver to start at the initial block
- for worker in solvers:
- worker.newBlockEvent.set()
-
- for worker in solvers:
- worker.start() # start the solver processes
-
- start_time = time.time() # time that the registration started
- time_last = start_time # time that the last work blocks completed
-
- curr_stats = RegistrationStatistics(
- time_spent_total=0.0,
- time_average=0.0,
- rounds_total=0,
- time_spent=0.0,
- hash_rate_perpetual=0.0,
- hash_rate=0.0,
- difficulty=difficulty,
- block_number=block_number,
- block_hash=block_hash,
- )
-
- start_time_perpetual = time.time()
-
- logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
- logger.start()
-
- solution = None
-
- hash_rates = [0] * n_samples # The last n true hash_rates
- weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
-
- while netuid == -1 or not subtensor.is_hotkey_registered(
- netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
- ):
- # Wait until a solver finds a solution
- try:
- solution = solution_queue.get(block=True, timeout=0.25)
- if solution is not None:
- break
- except Empty:
- # No solution found, try again
- pass
-
- # check for new block
- old_block_number = _check_for_newest_block_and_update(
- subtensor=subtensor,
- netuid=netuid,
- hotkey_bytes=hotkey_bytes,
- old_block_number=old_block_number,
- curr_diff=curr_diff,
- curr_block=curr_block,
- curr_block_num=curr_block_num,
- curr_stats=curr_stats,
- update_curr_block=_update_curr_block,
- check_block=check_block,
- solvers=solvers,
- )
-
- num_time = 0
- for finished_queue in finished_queues:
- try:
- proc_num = finished_queue.get(timeout=0.1)
- num_time += 1
-
- except Empty:
- continue
-
- time_now = time.time() # get current time
- time_since_last = time_now - time_last # get time since last work block(s)
- if num_time > 0 and time_since_last > 0.0:
- # create EWMA of the hash_rate to make measure more robust
-
- hash_rate_ = (num_time * update_interval) / time_since_last
- hash_rates.append(hash_rate_)
- hash_rates.pop(0) # remove the 0th data point
- curr_stats.hash_rate = sum(
- [hash_rates[i] * weights[i] for i in range(n_samples)]
- ) / (sum(weights))
-
- # update time last to now
- time_last = time_now
-
- curr_stats.time_average = (
- curr_stats.time_average * curr_stats.rounds_total
- + curr_stats.time_spent
- ) / (curr_stats.rounds_total + num_time)
- curr_stats.rounds_total += num_time
-
- # Update stats
- curr_stats.time_spent = time_since_last
- new_time_spent_total = time_now - start_time_perpetual
- curr_stats.hash_rate_perpetual = (
- curr_stats.rounds_total * update_interval
- ) / new_time_spent_total
- curr_stats.time_spent_total = new_time_spent_total
-
- # Update the logger
- logger.update(curr_stats, verbose=log_verbose)
-
- # exited while, solution contains the nonce or wallet is registered
- stopEvent.set() # stop all other processes
- logger.stop()
-
- # terminate and wait for all solvers to exit
- _terminate_workers_and_wait_for_exit(solvers)
-
- return solution
-
-
-@retry(Exception, tries=3, delay=1)
-def _get_block_with_retry(subtensor: "Subtensor", netuid: int) -> tuple[int, int, str]:
- """
- Gets the current block number, difficulty, and block hash from the substrate node.
-
- Args:
- subtensor (bittensor.core.subtensor.Subtensor): The subtensor object to use to get the block number, difficulty, and block hash.
- netuid (int): The netuid of the network to get the block number, difficulty, and block hash from.
-
- Returns:
- tuple[int, int, bytes]
- block_number (int): The current block number.
- difficulty (int): The current difficulty of the subnet.
- block_hash (bytes): The current block hash.
-
- Raises:
- Exception: If the block hash is None.
- ValueError: If the difficulty is None.
- """
- block_number = subtensor.get_current_block()
- difficulty = 1_000_000 if netuid == -1 else subtensor.difficulty(netuid=netuid)
- block_hash = subtensor.get_block_hash(block_number)
- if block_hash is None:
- raise Exception(
- "Network error. Could not connect to substrate to get block hash"
- )
- if difficulty is None:
- raise ValueError("Chain error. Difficulty is None")
- return block_number, difficulty, block_hash
-
-
-def _check_for_newest_block_and_update(
- subtensor: "Subtensor",
- netuid: int,
- old_block_number: int,
- hotkey_bytes: bytes,
- curr_diff: "multiprocessing.Array",
- curr_block: "multiprocessing.Array",
- curr_block_num: "multiprocessing.Value",
- update_curr_block: "Callable",
- check_block: "multiprocessing.Lock",
- solvers: Union[list["_Solver"], list["_CUDASolver"]],
- curr_stats: "RegistrationStatistics",
-) -> int:
- """
- Checks for a new block and updates the current block information if a new block is found.
-
- Args:
- subtensor (bittensor.core.subtensor.Subtensor): The subtensor object to use for getting the current block.
- netuid (int): The netuid to use for retrieving the difficulty.
- old_block_number (int): The old block number to check against.
- hotkey_bytes (bytes): The bytes of the hotkey's pubkey.
- curr_diff (multiprocessing.Array): The current difficulty as a multiprocessing array.
- curr_block (multiprocessing.Array): Where the current block is stored as a multiprocessing array.
- curr_block_num (multiprocessing.Value): Where the current block number is stored as a multiprocessing value.
- update_curr_block (typing.Callable): A function that updates the current block.
- check_block (multiprocessing.Lock): A mp lock that is used to check for a new block.
- solvers (list[bittensor.utils.registration._Solver]): A list of solvers to update the current block for.
- curr_stats (bittensor.utils.registration.RegistrationStatistics): The current registration statistics to update.
-
- Returns:
- (int) The current block number.
- """
- block_number = subtensor.get_current_block()
- if block_number != old_block_number:
- old_block_number = block_number
- # update block information
- block_number, difficulty, block_hash = _get_block_with_retry(
- subtensor=subtensor, netuid=netuid
- )
- block_bytes = bytes.fromhex(block_hash[2:])
-
- update_curr_block(
- curr_diff,
- curr_block,
- curr_block_num,
- block_number,
- block_bytes,
- difficulty,
- hotkey_bytes,
- check_block,
- )
- # Set new block events for each solver
-
- for worker in solvers:
- worker.newBlockEvent.set()
-
- # update stats
- curr_stats.block_number = block_number
- curr_stats.block_hash = block_hash
- curr_stats.difficulty = difficulty
-
- return old_block_number
-
-
-def _solve_for_difficulty_fast_cuda(
- subtensor: "Subtensor",
- wallet: "Wallet",
- netuid: int,
- output_in_place: bool = True,
- update_interval: int = 50_000,
- tpb: int = 512,
- dev_id: Union[list[int], int] = 0,
- n_samples: int = 10,
- alpha_: float = 0.80,
- log_verbose: bool = False,
-) -> Optional["POWSolution"]:
- """
- Solves the registration fast using CUDA.
-
- Args:
- subtensor (bittensor.core.subtensor.Subtensor): The subtensor node to grab blocks.
- wallet (bittensor_wallet.Wallet): The wallet to register.
- netuid (int): The netuid of the subnet to register to.
- output_in_place (bool) If true, prints the output in place, otherwise prints to new lines.
- update_interval (int): The number of nonces to try before checking for more blocks.
- tpb (int): The number of threads per block. CUDA param that should match the GPU capability
- dev_id (Union[list[int], int]): The CUDA device IDs to execute the registration on, either a single device or a list of devices.
- n_samples (int): The number of samples of the hash_rate to keep for the EWMA.
- alpha_ (float): The alpha for the EWMA for the hash_rate calculation.
- log_verbose (bool): If true, prints more verbose logging of the registration metrics.
-
- Note: The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
- """
- if isinstance(dev_id, int):
- dev_id = [dev_id]
- elif dev_id is None:
- dev_id = [0]
-
- if update_interval is None:
- update_interval = 50_000
-
- if not torch.cuda.is_available():
- raise Exception("CUDA not available")
-
- limit = int(math.pow(2, 256)) - 1
-
- # Set mp start to use spawn so CUDA doesn't complain
- with _UsingSpawnStartMethod(force=True):
- curr_block, curr_block_num, curr_diff = _CUDASolver.create_shared_memory()
-
- # Create a worker per CUDA device
- num_processes = len(dev_id)
-
- # Establish communication queues
- stopEvent = multiprocessing.Event()
- stopEvent.clear()
- solution_queue = multiprocessing.Queue()
- finished_queues = [multiprocessing.Queue() for _ in range(num_processes)]
- check_block = multiprocessing.Lock()
-
- hotkey_bytes = wallet.hotkey.public_key
- # Start workers
- solvers = [
- _CUDASolver(
- i,
- num_processes,
- update_interval,
- finished_queues[i],
- solution_queue,
- stopEvent,
- curr_block,
- curr_block_num,
- curr_diff,
- check_block,
- limit,
- dev_id[i],
- tpb,
- )
- for i in range(num_processes)
- ]
-
- # Get first block
- block_number, difficulty, block_hash = _get_block_with_retry(
- subtensor=subtensor, netuid=netuid
- )
-
- block_bytes = bytes.fromhex(block_hash[2:])
- old_block_number = block_number
-
- # Set to current block
- _update_curr_block(
- curr_diff,
- curr_block,
- curr_block_num,
- block_number,
- block_bytes,
- difficulty,
- hotkey_bytes,
- check_block,
- )
-
- # Set new block events for each solver to start at the initial block
- for worker in solvers:
- worker.newBlockEvent.set()
-
- for worker in solvers:
- worker.start() # start the solver processes
-
- start_time = time.time() # time that the registration started
- time_last = start_time # time that the last work blocks completed
-
- curr_stats = RegistrationStatistics(
- time_spent_total=0.0,
- time_average=0.0,
- rounds_total=0,
- time_spent=0.0,
- hash_rate_perpetual=0.0,
- hash_rate=0.0, # EWMA hash_rate (H/s)
- difficulty=difficulty,
- block_number=block_number,
- block_hash=block_hash,
- )
-
- start_time_perpetual = time.time()
-
- logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
- logger.start()
-
- hash_rates = [0] * n_samples # The last n true hash_rates
- weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
-
- solution = None
- while netuid == -1 or not subtensor.is_hotkey_registered(
- netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
- ):
- # Wait until a solver finds a solution
- try:
- solution = solution_queue.get(block=True, timeout=0.15)
- if solution is not None:
- break
- except Empty:
- # No solution found, try again
- pass
-
- # check for new block
- old_block_number = _check_for_newest_block_and_update(
- subtensor=subtensor,
- netuid=netuid,
- hotkey_bytes=hotkey_bytes,
- curr_diff=curr_diff,
- curr_block=curr_block,
- curr_block_num=curr_block_num,
- old_block_number=old_block_number,
- curr_stats=curr_stats,
- update_curr_block=_update_curr_block,
- check_block=check_block,
- solvers=solvers,
- )
-
- num_time = 0
- # Get times for each solver
- for finished_queue in finished_queues:
- try:
- proc_num = finished_queue.get(timeout=0.1)
- num_time += 1
-
- except Empty:
- continue
-
- time_now = time.time() # get current time
- time_since_last = time_now - time_last # get time since last work block(s)
- if num_time > 0 and time_since_last > 0.0:
- # create EWMA of the hash_rate to make measure more robust
-
- hash_rate_ = (num_time * tpb * update_interval) / time_since_last
- hash_rates.append(hash_rate_)
- hash_rates.pop(0) # remove the 0th data point
- curr_stats.hash_rate = sum(
- [hash_rates[i] * weights[i] for i in range(n_samples)]
- ) / (sum(weights))
-
- # update time last to now
- time_last = time_now
-
- curr_stats.time_average = (
- curr_stats.time_average * curr_stats.rounds_total
- + curr_stats.time_spent
- ) / (curr_stats.rounds_total + num_time)
- curr_stats.rounds_total += num_time
-
- # Update stats
- curr_stats.time_spent = time_since_last
- new_time_spent_total = time_now - start_time_perpetual
- curr_stats.hash_rate_perpetual = (
- curr_stats.rounds_total * (tpb * update_interval)
- ) / new_time_spent_total
- curr_stats.time_spent_total = new_time_spent_total
-
- # Update the logger
- logger.update(curr_stats, verbose=log_verbose)
-
- # exited while, found_solution contains the nonce or wallet is registered
-
- stopEvent.set() # stop all other processes
- logger.stop()
-
- # terminate and wait for all solvers to exit
- _terminate_workers_and_wait_for_exit(solvers)
-
- return solution
-
-
-def _terminate_workers_and_wait_for_exit(
- workers: list[Union[multiprocessing.Process, QueueType]],
-) -> None:
- for worker in workers:
- if isinstance(worker, QueueType):
- worker.join_thread()
- else:
- try:
- worker.join(3.0)
- except subprocess.TimeoutExpired:
- worker.terminate()
- try:
- worker.close()
- except ValueError:
- worker.terminate()
-
-
-def create_pow(
- subtensor: "Subtensor",
- wallet: "Wallet",
- netuid: int,
- output_in_place: bool = True,
- cuda: bool = False,
- dev_id: Union[list[int], int] = 0,
- tpb: int = 256,
- num_processes: Optional[int] = None,
- update_interval: Optional[int] = None,
- log_verbose: bool = False,
-) -> Optional[dict[str, Any]]:
- """
- Creates a proof of work for the given subtensor and wallet.
-
- Args:
- subtensor (bittensor.core.subtensor.Subtensor): The subtensor to create a proof of work for.
- wallet (bittensor_wallet.Wallet): The wallet to create a proof of work for.
- netuid (int): The netuid for the subnet to create a proof of work for.
- output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines. Default is ``True``.
- cuda (bool): If true, uses CUDA to solve the proof of work. Default is ``False``.
- dev_id (Union[List[int], int]): The CUDA device id(s) to use. If cuda is true and dev_id is a list, then multiple CUDA devices will be used to solve the proof of work. Default is ``0``.
- tpb (int): The number of threads per block to use when solving the proof of work. Should be a multiple of 32. Default is ``256``.
- num_processes (Optional[int]): The number of processes to use when solving the proof of work. If None, then the number of processes is equal to the number of CPU cores. Default is None.
- update_interval (Optional[int]): The number of nonces to run before checking for a new block. Default is ``None``.
- log_verbose (bool): If true, prints the progress of the proof of work more verbosely. Default is ``False``.
-
- Returns:
- Optional[Dict[str, Any]]: The proof of work solution or None if the wallet is already registered or there is a different error.
-
- Raises:
- ValueError: If the subnet does not exist.
- """
- if netuid != -1:
- if not subtensor.subnet_exists(netuid=netuid):
- raise ValueError(f"Subnet {netuid} does not exist.")
-
- if cuda:
- solution: Optional[POWSolution] = _solve_for_difficulty_fast_cuda(
- subtensor,
- wallet,
- netuid=netuid,
- output_in_place=output_in_place,
- dev_id=dev_id,
- tpb=tpb,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
- else:
- solution: Optional[POWSolution] = _solve_for_difficulty_fast(
- subtensor,
- wallet,
- netuid=netuid,
- output_in_place=output_in_place,
- num_processes=num_processes,
- update_interval=update_interval,
- log_verbose=log_verbose,
- )
- return solution
diff --git a/bittensor/utils/registration/__init__.py b/bittensor/utils/registration/__init__.py
new file mode 100644
index 0000000000..37a913e20a
--- /dev/null
+++ b/bittensor/utils/registration/__init__.py
@@ -0,0 +1,10 @@
+from bittensor.utils.registration.pow import (
+ create_pow,
+ legacy_torch_api_compat,
+ log_no_torch_error,
+ torch,
+ use_torch,
+ LazyLoadedTorch,
+ POWSolution,
+)
+from bittensor.utils.registration.async_pow import create_pow_async
diff --git a/bittensor/utils/registration/async_pow.py b/bittensor/utils/registration/async_pow.py
new file mode 100644
index 0000000000..02817620ac
--- /dev/null
+++ b/bittensor/utils/registration/async_pow.py
@@ -0,0 +1,537 @@
+"""This module provides async utilities for solving Proof-of-Work (PoW) challenges in Bittensor network."""
+
+import math
+import time
+from multiprocessing import Event, Lock, Array, Value, Queue
+from queue import Empty
+from typing import Callable, Union, Optional, TYPE_CHECKING
+
+from retry import retry
+from substrateinterface.exceptions import SubstrateRequestException
+
+from bittensor.utils.registration.pow import (
+ get_cpu_count,
+ update_curr_block,
+ terminate_workers_and_wait_for_exit,
+ CUDASolver,
+ LazyLoadedTorch,
+ RegistrationStatistics,
+ RegistrationStatisticsLogger,
+ Solver,
+ UsingSpawnStartMethod,
+)
+
+if TYPE_CHECKING:
+ from bittensor.core.async_subtensor import AsyncSubtensor
+ from bittensor_wallet import Wallet
+ from bittensor.utils.registration import POWSolution
+ import torch
+else:
+ torch = LazyLoadedTorch()
+
+
+@retry(Exception, tries=3, delay=1)
+async def _get_block_with_retry(
+ subtensor: "AsyncSubtensor", netuid: int
+) -> tuple[int, int, str]:
+ """
+ Gets the current block number, difficulty, and block hash from the substrate node.
+
+ Args:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The subtensor object to use to get the block number, difficulty, and block hash.
+ netuid (int): The netuid of the network to get the block number, difficulty, and block hash from.
+
+ Returns:
+ The current block number, difficulty of the subnet, block hash
+
+ Raises:
+ Exception: If the block hash is None.
+ ValueError: If the difficulty is None.
+ """
+ block = await subtensor.substrate.get_block()
+ block_hash = block["header"]["hash"]
+ block_number = block["header"]["number"]
+ try:
+ difficulty = (
+ 1_000_000
+ if netuid == -1
+ else int(
+ await subtensor.get_hyperparameter(
+ param_name="Difficulty", netuid=netuid, block_hash=block_hash
+ )
+ )
+ )
+ except TypeError:
+ raise ValueError("Chain error. Difficulty is None")
+ except SubstrateRequestException:
+ raise Exception(
+ "Network error. Could not connect to substrate to get block hash"
+ )
+ return block_number, difficulty, block_hash
+
+
+async def _check_for_newest_block_and_update(
+ subtensor: "AsyncSubtensor",
+ netuid: int,
+ old_block_number: int,
+ hotkey_bytes: bytes,
+ curr_diff: Array,
+ curr_block: Array,
+ curr_block_num: Value,
+ update_curr_block_: "Callable",
+ check_block: Lock,
+ solvers: list[Solver],
+ curr_stats: "RegistrationStatistics",
+) -> int:
+ """
+ Check for the newest block and update block-related information and states across solvers if a new block is detected.
+
+ Args:
+ subtensor (AsyncSubtensor): The subtensor instance interface.
+ netuid (int): The network UID for the blockchain.
+ old_block_number (int): The previously known block number.
+ hotkey_bytes (bytes): The bytes representation of the hotkey.
+ curr_diff (Array): The current difficulty level.
+ curr_block (Array): The current block information.
+ curr_block_num (Value): The current block number.
+ update_curr_block_ (Callable): Function to update current block information.
+ check_block (Lock): Lock object for synchronizing block checking.
+ solvers (list[Solver]): List of solvers to notify of new blocks.
+ curr_stats (RegistrationStatistics): Current registration statistics to update.
+
+ Returns:
+ int: The updated block number which is the same as the new block
+ number if it was detected, otherwise the old block number.
+ """
+ block_number = await subtensor.substrate.get_block_number(None)
+ if block_number != old_block_number:
+ old_block_number = block_number
+ # update block information
+ block_number, difficulty, block_hash = await _get_block_with_retry(
+ subtensor=subtensor, netuid=netuid
+ )
+ block_bytes = bytes.fromhex(block_hash[2:])
+
+ update_curr_block_(
+ curr_diff,
+ curr_block,
+ curr_block_num,
+ block_number,
+ block_bytes,
+ difficulty,
+ hotkey_bytes,
+ check_block,
+ )
+ # Set new block events for each solver
+
+ for worker in solvers:
+ worker.newBlockEvent.set()
+
+ # update stats
+ curr_stats.block_number = block_number
+ curr_stats.block_hash = block_hash
+ curr_stats.difficulty = difficulty
+
+ return old_block_number
+
+
+async def _block_solver(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ num_processes: int,
+ netuid: int,
+ dev_id: list[int],
+ tpb: int,
+ update_interval: int,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ n_samples,
+ alpha_,
+ output_in_place,
+ log_verbose,
+ cuda: bool,
+):
+ """Shared code used by the Solvers to solve the POW solution."""
+ limit = int(math.pow(2, 256)) - 1
+
+ if cuda:
+ num_processes = len(dev_id)
+
+ # Establish communication queues
+ # See the _Solver class for more information on the queues.
+ stop_event = Event()
+ stop_event.clear()
+
+ solution_queue = Queue()
+ finished_queues = [Queue() for _ in range(num_processes)]
+ check_block = Lock()
+
+ hotkey_bytes = (
+ wallet.coldkeypub.public_key if netuid == -1 else wallet.hotkey.public_key
+ )
+
+ if cuda:
+ # Create a worker per CUDA device
+ solvers = [
+ CUDASolver(
+ i,
+ num_processes,
+ update_interval,
+ finished_queues[i],
+ solution_queue,
+ stop_event,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ dev_id[i],
+ tpb,
+ )
+ for i in range(num_processes)
+ ]
+ else:
+ # Start consumers
+ solvers = [
+ Solver(
+ i,
+ num_processes,
+ update_interval,
+ finished_queues[i],
+ solution_queue,
+ stop_event,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ )
+ for i in range(num_processes)
+ ]
+
+ # Get first block
+ block_number, difficulty, block_hash = await _get_block_with_retry(
+ subtensor=subtensor, netuid=netuid
+ )
+
+ block_bytes = bytes.fromhex(block_hash[2:])
+ old_block_number = block_number
+ # Set to current block
+ update_curr_block(
+ curr_diff,
+ curr_block,
+ curr_block_num,
+ block_number,
+ block_bytes,
+ difficulty,
+ hotkey_bytes,
+ check_block,
+ )
+
+ # Set new block events for each solver to start at the initial block
+ for worker in solvers:
+ worker.newBlockEvent.set()
+
+ for worker in solvers:
+ worker.start() # start the solver processes
+
+ start_time = time.time() # time that the registration started
+ time_last = start_time # time that the last work blocks completed
+
+ curr_stats = RegistrationStatistics(
+ time_spent_total=0.0,
+ time_average=0.0,
+ rounds_total=0,
+ time_spent=0.0,
+ hash_rate_perpetual=0.0,
+ hash_rate=0.0,
+ difficulty=difficulty,
+ block_number=block_number,
+ block_hash=block_hash,
+ )
+
+ start_time_perpetual = time.time()
+
+ logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
+ logger.start()
+
+ solution = None
+
+ hash_rates = [0] * n_samples # The last n true hash_rates
+ weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
+
+ timeout = 0.15 if cuda else 0.15
+ while netuid == -1 or not await subtensor.is_hotkey_registered(
+ netuid, wallet.hotkey.ss58_address
+ ):
+ # Wait until a solver finds a solution
+ try:
+ solution = solution_queue.get(block=True, timeout=timeout)
+ if solution is not None:
+ break
+ except Empty:
+ # No solution found, try again
+ pass
+
+ # check for new block
+ old_block_number = await _check_for_newest_block_and_update(
+ subtensor=subtensor,
+ netuid=netuid,
+ hotkey_bytes=hotkey_bytes,
+ old_block_number=old_block_number,
+ curr_diff=curr_diff,
+ curr_block=curr_block,
+ curr_block_num=curr_block_num,
+ curr_stats=curr_stats,
+ update_curr_block_=update_curr_block,
+ check_block=check_block,
+ solvers=solvers,
+ )
+
+ num_time = 0
+ for finished_queue in finished_queues:
+ try:
+ finished_queue.get(timeout=0.1)
+ num_time += 1
+
+ except Empty:
+ continue
+
+ time_now = time.time() # get current time
+ time_since_last = time_now - time_last # get time since last work block(s)
+ if num_time > 0 and time_since_last > 0.0:
+ # create EWMA of the hash_rate to make measure more robust
+
+ if cuda:
+ hash_rate_ = (num_time * tpb * update_interval) / time_since_last
+ else:
+ hash_rate_ = (num_time * update_interval) / time_since_last
+ hash_rates.append(hash_rate_)
+ hash_rates.pop(0) # remove the 0th data point
+ curr_stats.hash_rate = sum(
+ [hash_rates[i] * weights[i] for i in range(n_samples)]
+ ) / (sum(weights))
+
+ # update time last to now
+ time_last = time_now
+
+ curr_stats.time_average = (
+ curr_stats.time_average * curr_stats.rounds_total
+ + curr_stats.time_spent
+ ) / (curr_stats.rounds_total + num_time)
+ curr_stats.rounds_total += num_time
+
+ # Update stats
+ curr_stats.time_spent = time_since_last
+ new_time_spent_total = time_now - start_time_perpetual
+ if cuda:
+ curr_stats.hash_rate_perpetual = (
+ curr_stats.rounds_total * (tpb * update_interval)
+ ) / new_time_spent_total
+ else:
+ curr_stats.hash_rate_perpetual = (
+ curr_stats.rounds_total * update_interval
+ ) / new_time_spent_total
+ curr_stats.time_spent_total = new_time_spent_total
+
+ # Update the logger
+ logger.update(curr_stats, verbose=log_verbose)
+
+ # exited while, solution contains the nonce or wallet is registered
+ stop_event.set() # stop all other processes
+ logger.stop()
+
+ # terminate and wait for all solvers to exit
+ terminate_workers_and_wait_for_exit(solvers)
+
+ return solution
+
+
+async def _solve_for_difficulty_fast_cuda(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ update_interval: int = 50_000,
+ tpb: int = 512,
+ dev_id: Union[list[int], int] = 0,
+ n_samples: int = 10,
+ alpha_: float = 0.80,
+ log_verbose: bool = False,
+) -> Optional["POWSolution"]:
+ """
+ Solves the registration fast using CUDA
+
+ Args:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The subtensor object to use to get the block number, difficulty, and block hash.
+ wallet (bittensor_wallet.Wallet): The wallet to register
+ netuid (int): The netuid of the subnet to register to.
+ output_in_place (bool): If true, prints the output in place, otherwise prints to new lines
+ update_interval (int): The number of nonces to try before checking for more blocks
+ tpb (int): The number of threads per block. CUDA param that should match the GPU capability
+ dev_id (Union[list[int], int]): The CUDA device IDs to execute the registration on, either a single device or a list of devices
+ n_samples (int): The number of samples of the hash_rate to keep for the EWMA
+ alpha_ (float): The alpha for the EWMA for the hash_rate calculation
+ log_verbose (bool): If true, prints more verbose logging of the registration metrics.
+
+ Note:
+ The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
+ """
+ if isinstance(dev_id, int):
+ dev_id = [dev_id]
+ elif dev_id is None:
+ dev_id = [0]
+
+ num_processes = min(1, get_cpu_count())
+
+ if update_interval is None:
+ update_interval = 50_000
+
+ if not torch.cuda.is_available():
+ raise Exception("CUDA not available")
+
+ # Set mp start to use spawn so CUDA doesn't complain
+ with UsingSpawnStartMethod(force=True):
+ curr_block, curr_block_num, curr_diff = CUDASolver.create_shared_memory()
+
+ solution = await _block_solver(
+ subtensor=subtensor,
+ wallet=wallet,
+ num_processes=num_processes,
+ netuid=netuid,
+ dev_id=dev_id,
+ tpb=tpb,
+ update_interval=update_interval,
+ curr_block=curr_block,
+ curr_block_num=curr_block_num,
+ curr_diff=curr_diff,
+ n_samples=n_samples,
+ alpha_=alpha_,
+ output_in_place=output_in_place,
+ log_verbose=log_verbose,
+ cuda=True,
+ )
+
+ return solution
+
+
+async def _solve_for_difficulty_fast(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ num_processes: Optional[int] = None,
+ update_interval: Optional[int] = None,
+ n_samples: int = 10,
+ alpha_: float = 0.80,
+ log_verbose: bool = False,
+) -> Optional["POWSolution"]:
+ """
+ Solves the POW for registration using multiprocessing.
+
+ Args:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The subtensor object to use to get the block number, difficulty, and block hash.
+ wallet (bittensor_wallet.Wallet): wallet to use for registration.
+ netuid (int): The netuid of the subnet to register to.
+ output_in_place (bool): If true, prints the status in place. Otherwise, prints the status on a new line.
+ num_processes (Optional[int]): Number of processes to use.
+ update_interval (Optional[int]): Number of nonces to solve before updating block information.
+ n_samples (int): The number of samples of the hash_rate to keep for the EWMA
+ alpha_ (float): The alpha for the EWMA for the hash_rate calculation
+ log_verbose (bool): If true, prints more verbose logging of the registration metrics.
+
+ Notes:
+ The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
+ We can also modify the update interval to do smaller blocks of work, while still updating the block information after a different number of nonces, to increase the transparency of the process while still keeping the speed.
+ """
+ if not num_processes:
+ # get the number of allowed processes for this process
+ num_processes = min(1, get_cpu_count())
+
+ if update_interval is None:
+ update_interval = 50_000
+
+ curr_block, curr_block_num, curr_diff = Solver.create_shared_memory()
+
+ solution = await _block_solver(
+ subtensor=subtensor,
+ wallet=wallet,
+ num_processes=num_processes,
+ netuid=netuid,
+ dev_id=None,
+ tpb=None,
+ update_interval=update_interval,
+ curr_block=curr_block,
+ curr_block_num=curr_block_num,
+ curr_diff=curr_diff,
+ n_samples=n_samples,
+ alpha_=alpha_,
+ output_in_place=output_in_place,
+ log_verbose=log_verbose,
+ cuda=False,
+ )
+
+ return solution
+
+
+async def create_pow_async(
+ subtensor: "AsyncSubtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ cuda: bool = False,
+ dev_id: Union[list[int], int] = 0,
+ tpb: int = 256,
+ num_processes: int = None,
+ update_interval: int = None,
+ log_verbose: bool = False,
+) -> "POWSolution":
+ """
+ Creates a proof of work for the given subtensor and wallet.
+
+ Args:
+ subtensor (bittensor.core.async_subtensor.AsyncSubtensor): The subtensor object to use to get the block number, difficulty, and block hash.
+ wallet (bittensor_wallet.Wallet): The wallet to create a proof of work for.
+ netuid (int): The netuid for the subnet to create a proof of work for.
+ output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines.
+ cuda (bool): If true, uses CUDA to solve the proof of work.
+ dev_id (Union[list[int], int]): The CUDA device id(s) to use. If cuda is true and dev_id is a list, then multiple CUDA devices will be used to solve the proof of work.
+ tpb (int): The number of threads per block to use when solving the proof of work. Should be a multiple of 32.
+ num_processes (int): The number of processes to use when solving the proof of work. If None, then the number of processes is equal to the number of CPU cores.
+ update_interval (int): The number of nonces to run before checking for a new block.
+ log_verbose (bool): If true, prints the progress of the proof of work more verbosely.
+
+ Returns:
+ The proof of work solution or None if the wallet is already registered or there is a different error.
+
+ Raises:
+ ValueError: If the subnet does not exist.
+ """
+ if netuid != -1:
+ if not await subtensor.subnet_exists(netuid=netuid):
+ raise ValueError(f"Subnet {netuid} does not exist")
+ solution: Optional[POWSolution]
+ if cuda:
+ solution = await _solve_for_difficulty_fast_cuda(
+ subtensor=subtensor,
+ wallet=wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
+ dev_id=dev_id,
+ tpb=tpb,
+ update_interval=update_interval,
+ log_verbose=log_verbose,
+ )
+ else:
+ solution = await _solve_for_difficulty_fast(
+ subtensor=subtensor,
+ wallet=wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
+ num_processes=num_processes,
+ update_interval=update_interval,
+ log_verbose=log_verbose,
+ )
+
+ return solution
diff --git a/bittensor/utils/registration/pow.py b/bittensor/utils/registration/pow.py
new file mode 100644
index 0000000000..c96295b0cd
--- /dev/null
+++ b/bittensor/utils/registration/pow.py
@@ -0,0 +1,1138 @@
+"""This module provides utilities for solving Proof-of-Work (PoW) challenges in Bittensor network."""
+
+import binascii
+from dataclasses import dataclass
+import functools
+import hashlib
+import math
+import multiprocessing as mp
+import os
+import random
+import subprocess
+import time
+from datetime import timedelta
+from multiprocessing.queues import Queue as QueueType
+from queue import Empty, Full
+from typing import Any, Callable, Optional, Union, TYPE_CHECKING
+
+import numpy
+from Crypto.Hash import keccak
+from rich import console as rich_console, status as rich_status
+from rich.console import Console
+
+from bittensor.utils.btlogging import logging
+from bittensor.utils.formatting import get_human_readable, millify
+from bittensor.utils.registration.register_cuda import solve_cuda
+
+
+def use_torch() -> bool:
+ """Force the use of torch over numpy for certain operations."""
+ return True if os.getenv("USE_TORCH") == "1" else False
+
+
+def legacy_torch_api_compat(func):
+ """
+ Convert function operating on numpy Input&Output to legacy torch Input&Output API if `use_torch()` is True.
+
+ Args:
+ func (function): Function with numpy Input/Output to be decorated.
+
+ Returns:
+ decorated (function): Decorated function.
+ """
+
+ @functools.wraps(func)
+ def decorated(*args, **kwargs):
+ if use_torch():
+ # if argument is a Torch tensor, convert it to numpy
+ args = [
+ arg.cpu().numpy() if isinstance(arg, torch.Tensor) else arg
+ for arg in args
+ ]
+ kwargs = {
+ key: value.cpu().numpy() if isinstance(value, torch.Tensor) else value
+ for key, value in kwargs.items()
+ }
+ ret = func(*args, **kwargs)
+ if use_torch():
+ # if return value is a numpy array, convert it to Torch tensor
+ if isinstance(ret, numpy.ndarray):
+ ret = torch.from_numpy(ret)
+ return ret
+
+ return decorated
+
+
+@functools.cache
+def _get_real_torch():
+ try:
+ import torch as _real_torch
+ except ImportError:
+ _real_torch = None
+ return _real_torch
+
+
+def log_no_torch_error():
+ logging.error(
+ "This command requires torch. You can install torch for bittensor"
+ ' with `pip install bittensor[torch]` or `pip install ".[torch]"`'
+ " if installing from source, and then run the command with USE_TORCH=1 {command}"
+ )
+
+
+class LazyLoadedTorch:
+ """A lazy-loading proxy for the torch module."""
+
+ def __bool__(self):
+ return bool(_get_real_torch())
+
+ def __getattr__(self, name):
+ if real_torch := _get_real_torch():
+ return getattr(real_torch, name)
+ else:
+ log_no_torch_error()
+ raise ImportError("torch not installed")
+
+
+if TYPE_CHECKING:
+ import torch
+ from bittensor.core.subtensor import Subtensor
+ from bittensor.core.async_subtensor import AsyncSubtensor
+ from bittensor_wallet import Wallet
+else:
+ torch = LazyLoadedTorch()
+
+
+def _hex_bytes_to_u8_list(hex_bytes: bytes) -> list[int]:
+ """ """
+ return [int(hex_bytes[i : i + 2], 16) for i in range(0, len(hex_bytes), 2)]
+
+
+def _create_seal_hash(block_and_hotkey_hash_bytes: bytes, nonce: int) -> bytes:
+ """
+ Create a cryptographic seal hash from the given block and hotkey hash bytes and nonce.
+
+ This function generates a seal hash by combining the given block and hotkey hash bytes with a nonce.
+ It first converts the nonce to a byte representation, then concatenates it with the first 64 hex characters of the block and hotkey hash bytes. The result is then hashed using SHA-256 followed by the Keccak-256 algorithm to produce the final seal hash.
+
+ Args:
+ block_and_hotkey_hash_bytes (bytes): The combined hash bytes of the block and hotkey.
+ nonce (int): The nonce value used for hashing.
+
+ Returns:
+ The resulting seal hash.
+ """
+ nonce_bytes = binascii.hexlify(nonce.to_bytes(8, "little"))
+ pre_seal = nonce_bytes + binascii.hexlify(block_and_hotkey_hash_bytes)[:64]
+ seal_sh256 = hashlib.sha256(bytearray(_hex_bytes_to_u8_list(pre_seal))).digest()
+ kec = keccak.new(digest_bits=256)
+ seal = kec.update(seal_sh256).digest()
+ return seal
+
+
+def _seal_meets_difficulty(seal: bytes, difficulty: int, limit: int) -> bool:
+ """Determines if a seal meets the specified difficulty."""
+ seal_number = int.from_bytes(seal, "big")
+ product = seal_number * difficulty
+ return product < limit
+
+
+@dataclass
+class POWSolution:
+ """A solution to the registration PoW problem."""
+
+ nonce: int
+ block_number: int
+ difficulty: int
+ seal: bytes
+
+ def is_stale(self, subtensor: "Subtensor") -> bool:
+ """
+ Synchronous implementation. Returns True if the POW is stale.
+
+ This means the block the POW is solved for is within 3 blocks of the current block.
+ """
+ return self.block_number < subtensor.get_current_block() - 3
+
+ async def is_stale_async(self, subtensor: "AsyncSubtensor") -> bool:
+ """
+ Asynchronous implementation. Returns True if the POW is stale.
+
+ This means the block the POW is solved for is within 3 blocks of the current block.
+ """
+ current_block = await subtensor.substrate.get_block_number(None)
+ return self.block_number < current_block - 3
+
+
+class UsingSpawnStartMethod:
+ def __init__(self, force: bool = False):
+ self._old_start_method = None
+ self._force = force
+
+ def __enter__(self):
+ self._old_start_method = mp.get_start_method(allow_none=True)
+ if self._old_start_method is None:
+ self._old_start_method = "spawn" # default to spawn
+
+ mp.set_start_method("spawn", force=self._force)
+
+ def __exit__(self, *args):
+ # restore the old start method
+ mp.set_start_method(self._old_start_method, force=True)
+
+
+class _SolverBase(mp.Process):
+ """
+ A process that solves the registration PoW problem.
+
+ Args:
+ proc_num (int): The number of the process being created.
+ num_proc (int): The total number of processes running.
+ update_interval (int): The number of nonces to try to solve before checking for a new block.
+ finished_queue (multiprocessing.Queue): The queue to put the process number when a process finishes each update_interval. Used for calculating the average time per update_interval across all processes.
+ solution_queue (multiprocessing.Queue): The queue to put the solution the process has found during the pow solve.
+ stopEvent (multiprocessing.Event): The event to set by the main process when all the solver processes should stop. The solver process will check for the event after each update_interval. The solver process will stop when the event is set. Used to stop the solver processes when a solution is found.
+ curr_block (multiprocessing.Array): The array containing this process's current block hash. The main process will set the array to the new block hash when a new block is finalized in the network. The solver process will get the new block hash from this array when newBlockEvent is set.
+ curr_block_num (multiprocessing.Value): The value containing this process's current block number. The main process will set the value to the new block number when a new block is finalized in the network. The solver process will get the new block number from this value when newBlockEvent is set.
+ curr_diff (multiprocessing.Array): The array containing this process's current difficulty. The main process will set the array to the new difficulty when a new block is finalized in the network. The solver process will get the new difficulty from this array when newBlockEvent is set.
+ check_block (multiprocessing.Lock): The lock to prevent this process from getting the new block data while the main process is updating the data.
+ limit (int): The limit of the pow solve for a valid solution.
+ """
+
+ proc_num: int
+ num_proc: int
+ update_interval: int
+ finished_queue: "mp.Queue"
+ solution_queue: "mp.Queue"
+ # newBlockEvent: "mp.Event"
+ newBlockEvent: "mp.Event"
+ stopEvent: "mp.Event"
+ hotkey_bytes: bytes
+ curr_block: "mp.Array"
+ curr_block_num: "mp.Value"
+ curr_diff: "mp.Array"
+ check_block: "mp.Lock"
+ limit: int
+
+ def __init__(
+ self,
+ proc_num,
+ num_proc,
+ update_interval,
+ finished_queue,
+ solution_queue,
+ stopEvent,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ ):
+ mp.Process.__init__(self, daemon=True)
+ self.proc_num = proc_num
+ self.num_proc = num_proc
+ self.update_interval = update_interval
+ self.finished_queue = finished_queue
+ self.solution_queue = solution_queue
+ self.newBlockEvent = mp.Event()
+ self.newBlockEvent.clear()
+ self.curr_block = curr_block
+ self.curr_block_num = curr_block_num
+ self.curr_diff = curr_diff
+ self.check_block = check_block
+ self.stopEvent = stopEvent
+ self.limit = limit
+
+ def run(self):
+ raise NotImplementedError("_SolverBase is an abstract class")
+
+ @staticmethod
+ def create_shared_memory() -> tuple["mp.Array", "mp.Value", "mp.Array"]:
+ """Creates shared memory for the solver processes to use."""
+ curr_block = mp.Array("h", 32, lock=True) # byte array
+ curr_block_num = mp.Value("i", 0, lock=True) # int
+ curr_diff = mp.Array("Q", [0, 0], lock=True) # [high, low]
+
+ return curr_block, curr_block_num, curr_diff
+
+
+class Solver(_SolverBase):
+ def run(self):
+ block_number: int
+ block_and_hotkey_hash_bytes: bytes
+ block_difficulty: int
+ nonce_limit = int(math.pow(2, 64)) - 1
+
+ # Start at random nonce
+ nonce_start = random.randint(0, nonce_limit)
+ nonce_end = nonce_start + self.update_interval
+ while not self.stopEvent.is_set():
+ if self.newBlockEvent.is_set():
+ with self.check_block:
+ block_number = self.curr_block_num.value
+ block_and_hotkey_hash_bytes = bytes(self.curr_block)
+ block_difficulty = _registration_diff_unpack(self.curr_diff)
+
+ self.newBlockEvent.clear()
+
+ # Do a block of nonces
+ solution = _solve_for_nonce_block(
+ nonce_start,
+ nonce_end,
+ block_and_hotkey_hash_bytes,
+ block_difficulty,
+ self.limit,
+ block_number,
+ )
+ if solution is not None:
+ self.solution_queue.put(solution)
+
+ try:
+ # Send time
+ self.finished_queue.put_nowait(self.proc_num)
+ except Full:
+ pass
+
+ nonce_start = random.randint(0, nonce_limit)
+ nonce_start = nonce_start % nonce_limit
+ nonce_end = nonce_start + self.update_interval
+
+
+class CUDASolver(_SolverBase):
+ dev_id: int
+ tpb: int
+
+ def __init__(
+ self,
+ proc_num,
+ num_proc,
+ update_interval,
+ finished_queue,
+ solution_queue,
+ stopEvent,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ dev_id: int,
+ tpb: int,
+ ):
+ super().__init__(
+ proc_num,
+ num_proc,
+ update_interval,
+ finished_queue,
+ solution_queue,
+ stopEvent,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ )
+ self.dev_id = dev_id
+ self.tpb = tpb
+
+ def run(self):
+ block_number: int = 0 # dummy value
+ block_and_hotkey_hash_bytes: bytes = b"0" * 32 # dummy value
+ block_difficulty: int = int(math.pow(2, 64)) - 1 # dummy value
+ nonce_limit = int(math.pow(2, 64)) - 1 # U64MAX
+
+ # Start at random nonce
+ nonce_start = random.randint(0, nonce_limit)
+ while not self.stopEvent.is_set():
+ if self.newBlockEvent.is_set():
+ with self.check_block:
+ block_number = self.curr_block_num.value
+ block_and_hotkey_hash_bytes = bytes(self.curr_block)
+ block_difficulty = _registration_diff_unpack(self.curr_diff)
+
+ self.newBlockEvent.clear()
+
+ # Do a block of nonces
+ solution = _solve_for_nonce_block_cuda(
+ nonce_start,
+ self.update_interval,
+ block_and_hotkey_hash_bytes,
+ block_difficulty,
+ self.limit,
+ block_number,
+ self.dev_id,
+ self.tpb,
+ )
+ if solution is not None:
+ self.solution_queue.put(solution)
+
+ try:
+ # Signal that a nonce_block was finished using queue
+ # send our proc_num
+ self.finished_queue.put(self.proc_num)
+ except Full:
+ pass
+
+ # increase nonce by number of nonces processed
+ nonce_start += self.update_interval * self.tpb
+ nonce_start = nonce_start % nonce_limit
+
+
+def _solve_for_nonce_block_cuda(
+ nonce_start: int,
+ update_interval: int,
+ block_and_hotkey_hash_bytes: bytes,
+ difficulty: int,
+ limit: int,
+ block_number: int,
+ dev_id: int,
+ tpb: int,
+) -> Optional["POWSolution"]:
+ """Tries to solve the POW on a CUDA device for a block of nonces (nonce_start, nonce_start + update_interval * tpb"""
+ solution, seal = solve_cuda(
+ nonce_start,
+ update_interval,
+ tpb,
+ block_and_hotkey_hash_bytes,
+ difficulty,
+ limit,
+ dev_id,
+ )
+
+ if solution != -1:
+ # Check if solution is valid (i.e. not -1)
+ return POWSolution(solution, block_number, difficulty, seal)
+
+ return None
+
+
+def _solve_for_nonce_block(
+ nonce_start: int,
+ nonce_end: int,
+ block_and_hotkey_hash_bytes: bytes,
+ difficulty: int,
+ limit: int,
+ block_number: int,
+) -> Optional["POWSolution"]:
+ """Tries to solve the POW for a block of nonces (nonce_start, nonce_end)"""
+ for nonce in range(nonce_start, nonce_end):
+ # Create seal.
+ seal = _create_seal_hash(block_and_hotkey_hash_bytes, nonce)
+
+ # Check if seal meets difficulty
+ if _seal_meets_difficulty(seal, difficulty, limit):
+ # Found a solution, save it.
+ return POWSolution(nonce, block_number, difficulty, seal)
+
+ return None
+
+
+def _registration_diff_unpack(packed_diff: "mp.Array") -> int:
+ """Unpacks the packed two 32-bit integers into one 64-bit integer. Little endian."""
+ return int(packed_diff[0] << 32 | packed_diff[1])
+
+
+def _registration_diff_pack(diff: int, packed_diff: "mp.Array"):
+ """Packs the difficulty into two 32-bit integers. Little endian."""
+ packed_diff[0] = diff >> 32
+ packed_diff[1] = diff & 0xFFFFFFFF # low 32 bits
+
+
+def _hash_block_with_hotkey(block_bytes: bytes, hotkey_bytes: bytes) -> bytes:
+ """Hashes the block with the hotkey using Keccak-256 to get 32 bytes"""
+ kec = keccak.new(digest_bits=256)
+ kec = kec.update(bytearray(block_bytes + hotkey_bytes))
+ block_and_hotkey_hash_bytes = kec.digest()
+ return block_and_hotkey_hash_bytes
+
+
+def update_curr_block(
+ curr_diff: "mp.Array",
+ curr_block: "mp.Array",
+ curr_block_num: "mp.Value",
+ block_number: int,
+ block_bytes: bytes,
+ diff: int,
+ hotkey_bytes: bytes,
+ lock: "mp.Lock",
+):
+ """
+ Update the current block data with the provided block information and difficulty.
+
+ This function updates the current block and its difficulty in a thread-safe manner. It sets the current block number, hashes the block with the hotkey, updates the current block bytes, and packs the difficulty.
+
+ Arguments:
+ curr_diff: Shared array to store the current difficulty.
+ curr_block: Shared array to store the current block data.
+ curr_block_num: Shared value to store the current block number.
+ block_number: The block number to set as the current block number.
+ block_bytes: The block data bytes to be hashed with the hotkey.
+ diff: The difficulty value to be packed into the current difficulty array.
+ hotkey_bytes: The hotkey bytes used for hashing the block.
+ lock: A lock to ensure thread-safe updates.
+ """
+ with lock:
+ curr_block_num.value = block_number
+ # Hash the block with the hotkey
+ block_and_hotkey_hash_bytes = _hash_block_with_hotkey(block_bytes, hotkey_bytes)
+ for i in range(32):
+ curr_block[i] = block_and_hotkey_hash_bytes[i]
+ _registration_diff_pack(diff, curr_diff)
+
+
+def get_cpu_count() -> int:
+ """Returns the number of CPUs in the system."""
+ try:
+ return len(os.sched_getaffinity(0))
+ except AttributeError:
+ # macOS does not have sched_getaffinity
+ return os.cpu_count()
+
+
+@dataclass
+class RegistrationStatistics:
+ """Statistics for a registration."""
+
+ time_spent_total: float
+ rounds_total: int
+ time_average: float
+ time_spent: float
+ hash_rate_perpetual: float
+ hash_rate: float
+ difficulty: int
+ block_number: int
+ block_hash: str
+
+
+class RegistrationStatisticsLogger:
+ """Logs statistics for a registration."""
+
+ status: Optional[rich_status.Status]
+
+ def __init__(
+ self,
+ console: Optional[rich_console.Console] = None,
+ output_in_place: bool = True,
+ ) -> None:
+ if console is None:
+ console = Console()
+
+ self.console = console
+
+ if output_in_place:
+ self.status = self.console.status("Solving")
+ else:
+ self.status = None
+
+ def start(self) -> None:
+ if self.status is not None:
+ self.status.start()
+
+ def stop(self) -> None:
+ if self.status is not None:
+ self.status.stop()
+
+ @classmethod
+ def get_status_message(
+ cls, stats: "RegistrationStatistics", verbose: bool = False
+ ) -> str:
+ """Generates the status message based on registration statistics."""
+ message = (
+ "Solving\n"
+ + f"Time Spent (total): [bold white]{timedelta(seconds=stats.time_spent_total)}[/bold white]\n"
+ + (
+ f"Time Spent This Round: {timedelta(seconds=stats.time_spent)}\n"
+ + f"Time Spent Average: {timedelta(seconds=stats.time_average)}\n"
+ if verbose
+ else ""
+ )
+ + f"Registration Difficulty: [bold white]{millify(stats.difficulty)}[/bold white]\n"
+ + f"Iters (Inst/Perp): [bold white]{get_human_readable(stats.hash_rate, 'H')}/s / "
+ + f"{get_human_readable(stats.hash_rate_perpetual, 'H')}/s[/bold white]\n"
+ + f"Block Number: [bold white]{stats.block_number}[/bold white]\n"
+ + f"Block Hash: [bold white]{stats.block_hash.encode('utf-8')}[/bold white]\n"
+ )
+ return message
+
+ def update(self, stats: "RegistrationStatistics", verbose: bool = False) -> None:
+ if self.status is not None:
+ self.status.update(self.get_status_message(stats, verbose=verbose))
+ else:
+ self.console.log(self.get_status_message(stats, verbose=verbose))
+
+
+def _solve_for_difficulty_fast(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ num_processes: Optional[int] = None,
+ update_interval: Optional[int] = None,
+ n_samples: int = 10,
+ alpha_: float = 0.80,
+ log_verbose: bool = False,
+) -> Optional[POWSolution]:
+ """
+ Solves the POW for registration using multiprocessing.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): Subtensor instance to connect to for block information and to submit.
+ wallet (bittensor_wallet.Wallet): wallet to use for registration.
+ netuid (int): The netuid of the subnet to register to.
+ output_in_place (bool): If true, prints the status in place. Otherwise, prints the status on a new line.
+ num_processes (int): Number of processes to use.
+ update_interval (int): Number of nonces to solve before updating block information.
+ n_samples (int): The number of samples of the hash_rate to keep for the EWMA.
+ alpha_ (float): The alpha for the EWMA for the hash_rate calculation.
+ log_verbose (bool): If true, prints more verbose logging of the registration metrics.
+
+ Note: The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
+ Note: We can also modify the update interval to do smaller blocks of work, while still updating the block information after a different number of nonces, to increase the transparency of the process while still keeping the speed.
+ """
+ if num_processes is None:
+ # get the number of allowed processes for this process
+ num_processes = min(1, get_cpu_count())
+
+ if update_interval is None:
+ update_interval = 50_000
+
+ limit = int(math.pow(2, 256)) - 1
+
+ curr_block, curr_block_num, curr_diff = Solver.create_shared_memory()
+
+ # Establish communication queues
+ # See the Solver class for more information on the queues.
+ stopEvent = mp.Event()
+ stopEvent.clear()
+
+ solution_queue = mp.Queue()
+ finished_queues = [mp.Queue() for _ in range(num_processes)]
+ check_block = mp.Lock()
+
+ hotkey_bytes = (
+ wallet.coldkeypub.public_key if netuid == -1 else wallet.hotkey.public_key
+ )
+ # Start consumers
+ solvers = [
+ Solver(
+ i,
+ num_processes,
+ update_interval,
+ finished_queues[i],
+ solution_queue,
+ stopEvent,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ )
+ for i in range(num_processes)
+ ]
+
+ # Get first block
+ block_number, difficulty, block_hash = _get_block_with_retry(
+ subtensor=subtensor, netuid=netuid
+ )
+
+ block_bytes = bytes.fromhex(block_hash[2:])
+ old_block_number = block_number
+ # Set to current block
+ update_curr_block(
+ curr_diff,
+ curr_block,
+ curr_block_num,
+ block_number,
+ block_bytes,
+ difficulty,
+ hotkey_bytes,
+ check_block,
+ )
+
+ # Set new block events for each solver to start at the initial block
+ for worker in solvers:
+ worker.newBlockEvent.set()
+
+ for worker in solvers:
+ worker.start() # start the solver processes
+
+ start_time = time.time() # time that the registration started
+ time_last = start_time # time that the last work blocks completed
+
+ curr_stats = RegistrationStatistics(
+ time_spent_total=0.0,
+ time_average=0.0,
+ rounds_total=0,
+ time_spent=0.0,
+ hash_rate_perpetual=0.0,
+ hash_rate=0.0,
+ difficulty=difficulty,
+ block_number=block_number,
+ block_hash=block_hash,
+ )
+
+ start_time_perpetual = time.time()
+
+ logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
+ logger.start()
+
+ solution = None
+
+ hash_rates = [0] * n_samples # The last n true hash_rates
+ weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
+
+ while netuid == -1 or not subtensor.is_hotkey_registered(
+ netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
+ ):
+ # Wait until a solver finds a solution
+ try:
+ solution = solution_queue.get(block=True, timeout=0.25)
+ if solution is not None:
+ break
+ except Empty:
+ # No solution found, try again
+ pass
+
+ # check for new block
+ old_block_number = _check_for_newest_block_and_update(
+ subtensor=subtensor,
+ netuid=netuid,
+ hotkey_bytes=hotkey_bytes,
+ old_block_number=old_block_number,
+ curr_diff=curr_diff,
+ curr_block=curr_block,
+ curr_block_num=curr_block_num,
+ curr_stats=curr_stats,
+ update_curr_block_=update_curr_block,
+ check_block=check_block,
+ solvers=solvers,
+ )
+
+ num_time = 0
+ for finished_queue in finished_queues:
+ try:
+ finished_queue.get(timeout=0.1)
+ num_time += 1
+
+ except Empty:
+ continue
+
+ time_now = time.time() # get current time
+ time_since_last = time_now - time_last # get time since last work block(s)
+ if num_time > 0 and time_since_last > 0.0:
+ # create EWMA of the hash_rate to make measure more robust
+
+ hash_rate_ = (num_time * update_interval) / time_since_last
+ hash_rates.append(hash_rate_)
+ hash_rates.pop(0) # remove the 0th data point
+ curr_stats.hash_rate = sum(
+ [hash_rates[i] * weights[i] for i in range(n_samples)]
+ ) / (sum(weights))
+
+ # update time last to now
+ time_last = time_now
+
+ curr_stats.time_average = (
+ curr_stats.time_average * curr_stats.rounds_total
+ + curr_stats.time_spent
+ ) / (curr_stats.rounds_total + num_time)
+ curr_stats.rounds_total += num_time
+
+ # Update stats
+ curr_stats.time_spent = time_since_last
+ new_time_spent_total = time_now - start_time_perpetual
+ curr_stats.hash_rate_perpetual = (
+ curr_stats.rounds_total * update_interval
+ ) / new_time_spent_total
+ curr_stats.time_spent_total = new_time_spent_total
+
+ # Update the logger
+ logger.update(curr_stats, verbose=log_verbose)
+
+ # exited while, solution contains the nonce or wallet is registered
+ stopEvent.set() # stop all other processes
+ logger.stop()
+
+ # terminate and wait for all solvers to exit
+ terminate_workers_and_wait_for_exit(solvers)
+
+ return solution
+
+
+def _get_block_with_retry(subtensor: "Subtensor", netuid: int) -> tuple[int, int, str]:
+ """
+ Gets the current block number, difficulty, and block hash from the substrate node.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): The subtensor object to use to get the block number, difficulty, and block hash.
+ netuid (int): The netuid of the network to get the block number, difficulty, and block hash from.
+
+ Returns:
+ tuple[int, int, bytes]
+ block_number (int): The current block number.
+ difficulty (int): The current difficulty of the subnet.
+ block_hash (bytes): The current block hash.
+
+ Raises:
+ Exception: If the block hash is None.
+ ValueError: If the difficulty is None.
+ """
+ block_number = subtensor.get_current_block()
+ difficulty = 1_000_000 if netuid == -1 else subtensor.difficulty(netuid=netuid)
+ block_hash = subtensor.get_block_hash(block_number)
+ if block_hash is None:
+ raise Exception(
+ "Network error. Could not connect to substrate to get block hash"
+ )
+ if difficulty is None:
+ raise ValueError("Chain error. Difficulty is None")
+ return block_number, difficulty, block_hash
+
+
+def _check_for_newest_block_and_update(
+ subtensor: "Subtensor",
+ netuid: int,
+ old_block_number: int,
+ hotkey_bytes: bytes,
+ curr_diff: "mp.Array",
+ curr_block: "mp.Array",
+ curr_block_num: "mp.Value",
+ update_curr_block_: "Callable",
+ check_block: "mp.Lock",
+ solvers: Union[list["Solver"], list["CUDASolver"]],
+ curr_stats: "RegistrationStatistics",
+) -> int:
+ """
+ Checks for a new block and updates the current block information if a new block is found.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): The subtensor object to use for getting the current block.
+ netuid (int): The netuid to use for retrieving the difficulty.
+ old_block_number (int): The old block number to check against.
+ hotkey_bytes (bytes): The bytes of the hotkey's pubkey.
+ curr_diff (multiprocessing.Array): The current difficulty as a multiprocessing array.
+ curr_block (multiprocessing.Array): Where the current block is stored as a multiprocessing array.
+ curr_block_num (multiprocessing.Value): Where the current block number is stored as a multiprocessing value.
+ update_curr_block_ (typing.Callable): A function that updates the current block.
+ check_block (multiprocessing.Lock): A mp lock that is used to check for a new block.
+ solvers (list[bittensor.utils.registration.Solver]): A list of solvers to update the current block for.
+ curr_stats (bittensor.utils.registration.RegistrationStatistics): The current registration statistics to update.
+
+ Returns:
+ (int) The current block number.
+ """
+ block_number = subtensor.get_current_block()
+ if block_number != old_block_number:
+ old_block_number = block_number
+ # update block information
+ block_number, difficulty, block_hash = _get_block_with_retry(
+ subtensor=subtensor, netuid=netuid
+ )
+ block_bytes = bytes.fromhex(block_hash[2:])
+
+ update_curr_block_(
+ curr_diff,
+ curr_block,
+ curr_block_num,
+ block_number,
+ block_bytes,
+ difficulty,
+ hotkey_bytes,
+ check_block,
+ )
+ # Set new block events for each solver
+
+ for worker in solvers:
+ worker.newBlockEvent.set()
+
+ # update stats
+ curr_stats.block_number = block_number
+ curr_stats.block_hash = block_hash
+ curr_stats.difficulty = difficulty
+
+ return old_block_number
+
+
+def _solve_for_difficulty_fast_cuda(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ update_interval: int = 50_000,
+ tpb: int = 512,
+ dev_id: Union[list[int], int] = 0,
+ n_samples: int = 10,
+ alpha_: float = 0.80,
+ log_verbose: bool = False,
+) -> Optional["POWSolution"]:
+ """
+ Solves the registration fast using CUDA.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): The subtensor node to grab blocks.
+ wallet (bittensor_wallet.Wallet): The wallet to register.
+ netuid (int): The netuid of the subnet to register to.
+ output_in_place (bool) If true, prints the output in place, otherwise prints to new lines.
+ update_interval (int): The number of nonces to try before checking for more blocks.
+ tpb (int): The number of threads per block. CUDA param that should match the GPU capability
+ dev_id (Union[list[int], int]): The CUDA device IDs to execute the registration on, either a single device or a list of devices.
+ n_samples (int): The number of samples of the hash_rate to keep for the EWMA.
+ alpha_ (float): The alpha for the EWMA for the hash_rate calculation.
+ log_verbose (bool): If true, prints more verbose logging of the registration metrics.
+
+ Note: The hash rate is calculated as an exponentially weighted moving average in order to make the measure more robust.
+ """
+ if isinstance(dev_id, int):
+ dev_id = [dev_id]
+ elif dev_id is None:
+ dev_id = [0]
+
+ if update_interval is None:
+ update_interval = 50_000
+
+ if not torch.cuda.is_available():
+ raise Exception("CUDA not available")
+
+ limit = int(math.pow(2, 256)) - 1
+
+ # Set mp start to use spawn so CUDA doesn't complain
+ with UsingSpawnStartMethod(force=True):
+ curr_block, curr_block_num, curr_diff = CUDASolver.create_shared_memory()
+
+ # Create a worker per CUDA device
+ num_processes = len(dev_id)
+
+ # Establish communication queues
+ stopEvent = mp.Event()
+ stopEvent.clear()
+ solution_queue = mp.Queue()
+ finished_queues = [mp.Queue() for _ in range(num_processes)]
+ check_block = mp.Lock()
+
+ hotkey_bytes = wallet.hotkey.public_key
+ # Start workers
+ solvers = [
+ CUDASolver(
+ i,
+ num_processes,
+ update_interval,
+ finished_queues[i],
+ solution_queue,
+ stopEvent,
+ curr_block,
+ curr_block_num,
+ curr_diff,
+ check_block,
+ limit,
+ dev_id[i],
+ tpb,
+ )
+ for i in range(num_processes)
+ ]
+
+ # Get first block
+ block_number, difficulty, block_hash = _get_block_with_retry(
+ subtensor=subtensor, netuid=netuid
+ )
+
+ block_bytes = bytes.fromhex(block_hash[2:])
+ old_block_number = block_number
+
+ # Set to current block
+ update_curr_block(
+ curr_diff,
+ curr_block,
+ curr_block_num,
+ block_number,
+ block_bytes,
+ difficulty,
+ hotkey_bytes,
+ check_block,
+ )
+
+ # Set new block events for each solver to start at the initial block
+ for worker in solvers:
+ worker.newBlockEvent.set()
+
+ for worker in solvers:
+ worker.start() # start the solver processes
+
+ start_time = time.time() # time that the registration started
+ time_last = start_time # time that the last work blocks completed
+
+ curr_stats = RegistrationStatistics(
+ time_spent_total=0.0,
+ time_average=0.0,
+ rounds_total=0,
+ time_spent=0.0,
+ hash_rate_perpetual=0.0,
+ hash_rate=0.0, # EWMA hash_rate (H/s)
+ difficulty=difficulty,
+ block_number=block_number,
+ block_hash=block_hash,
+ )
+
+ start_time_perpetual = time.time()
+
+ logger = RegistrationStatisticsLogger(output_in_place=output_in_place)
+ logger.start()
+
+ hash_rates = [0] * n_samples # The last n true hash_rates
+ weights = [alpha_**i for i in range(n_samples)] # weights decay by alpha
+
+ solution = None
+ while netuid == -1 or not subtensor.is_hotkey_registered(
+ netuid=netuid, hotkey_ss58=wallet.hotkey.ss58_address
+ ):
+ # Wait until a solver finds a solution
+ try:
+ solution = solution_queue.get(block=True, timeout=0.15)
+ if solution is not None:
+ break
+ except Empty:
+ # No solution found, try again
+ pass
+
+ # check for new block
+ old_block_number = _check_for_newest_block_and_update(
+ subtensor=subtensor,
+ netuid=netuid,
+ hotkey_bytes=hotkey_bytes,
+ curr_diff=curr_diff,
+ curr_block=curr_block,
+ curr_block_num=curr_block_num,
+ old_block_number=old_block_number,
+ curr_stats=curr_stats,
+ update_curr_block_=update_curr_block,
+ check_block=check_block,
+ solvers=solvers,
+ )
+
+ num_time = 0
+ # Get times for each solver
+ for finished_queue in finished_queues:
+ try:
+ finished_queue.get(timeout=0.1)
+ num_time += 1
+
+ except Empty:
+ continue
+
+ time_now = time.time() # get current time
+ time_since_last = time_now - time_last # get time since last work block(s)
+ if num_time > 0 and time_since_last > 0.0:
+ # create EWMA of the hash_rate to make measure more robust
+
+ hash_rate_ = (num_time * tpb * update_interval) / time_since_last
+ hash_rates.append(hash_rate_)
+ hash_rates.pop(0) # remove the 0th data point
+ curr_stats.hash_rate = sum(
+ [hash_rates[i] * weights[i] for i in range(n_samples)]
+ ) / (sum(weights))
+
+ # update time last to now
+ time_last = time_now
+
+ curr_stats.time_average = (
+ curr_stats.time_average * curr_stats.rounds_total
+ + curr_stats.time_spent
+ ) / (curr_stats.rounds_total + num_time)
+ curr_stats.rounds_total += num_time
+
+ # Update stats
+ curr_stats.time_spent = time_since_last
+ new_time_spent_total = time_now - start_time_perpetual
+ curr_stats.hash_rate_perpetual = (
+ curr_stats.rounds_total * (tpb * update_interval)
+ ) / new_time_spent_total
+ curr_stats.time_spent_total = new_time_spent_total
+
+ # Update the logger
+ logger.update(curr_stats, verbose=log_verbose)
+
+ # exited while, found_solution contains the nonce or wallet is registered
+
+ stopEvent.set() # stop all other processes
+ logger.stop()
+
+ # terminate and wait for all solvers to exit
+ terminate_workers_and_wait_for_exit(solvers)
+
+ return solution
+
+
+def terminate_workers_and_wait_for_exit(
+ workers: list[Union[mp.Process, QueueType]],
+) -> None:
+ for worker in workers:
+ if isinstance(worker, QueueType):
+ worker.join_thread()
+ else:
+ try:
+ worker.join(3.0)
+ except subprocess.TimeoutExpired:
+ worker.terminate()
+ try:
+ worker.close()
+ except ValueError:
+ worker.terminate()
+
+
+def create_pow(
+ subtensor: "Subtensor",
+ wallet: "Wallet",
+ netuid: int,
+ output_in_place: bool = True,
+ cuda: bool = False,
+ dev_id: Union[list[int], int] = 0,
+ tpb: int = 256,
+ num_processes: Optional[int] = None,
+ update_interval: Optional[int] = None,
+ log_verbose: bool = False,
+) -> Optional[dict[str, Any]]:
+ """
+ Creates a proof of work for the given subtensor and wallet.
+
+ Args:
+ subtensor (bittensor.core.subtensor.Subtensor): The subtensor to create a proof of work for.
+ wallet (bittensor_wallet.Wallet): The wallet to create a proof of work for.
+ netuid (int): The netuid for the subnet to create a proof of work for.
+ output_in_place (bool): If true, prints the progress of the proof of work to the console in-place. Meaning the progress is printed on the same lines. Default is ``True``.
+ cuda (bool): If true, uses CUDA to solve the proof of work. Default is ``False``.
+ dev_id (Union[List[int], int]): The CUDA device id(s) to use. If cuda is true and dev_id is a list, then multiple CUDA devices will be used to solve the proof of work. Default is ``0``.
+ tpb (int): The number of threads per block to use when solving the proof of work. Should be a multiple of 32. Default is ``256``.
+ num_processes (Optional[int]): The number of processes to use when solving the proof of work. If None, then the number of processes is equal to the number of CPU cores. Default is None.
+ update_interval (Optional[int]): The number of nonces to run before checking for a new block. Default is ``None``.
+ log_verbose (bool): If true, prints the progress of the proof of work more verbosely. Default is ``False``.
+
+ Returns:
+ Optional[Dict[str, Any]]: The proof of work solution or None if the wallet is already registered or there is a different error.
+
+ Raises:
+ ValueError: If the subnet does not exist.
+ """
+ if netuid != -1:
+ if not subtensor.subnet_exists(netuid=netuid):
+ raise ValueError(f"Subnet {netuid} does not exist.")
+
+ if cuda:
+ solution: Optional[POWSolution] = _solve_for_difficulty_fast_cuda(
+ subtensor,
+ wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
+ dev_id=dev_id,
+ tpb=tpb,
+ update_interval=update_interval,
+ log_verbose=log_verbose,
+ )
+ else:
+ solution: Optional[POWSolution] = _solve_for_difficulty_fast(
+ subtensor,
+ wallet,
+ netuid=netuid,
+ output_in_place=output_in_place,
+ num_processes=num_processes,
+ update_interval=update_interval,
+ log_verbose=log_verbose,
+ )
+ return solution
diff --git a/bittensor/utils/register_cuda.py b/bittensor/utils/registration/register_cuda.py
similarity index 54%
rename from bittensor/utils/register_cuda.py
rename to bittensor/utils/registration/register_cuda.py
index e0a77f19c9..756250f068 100644
--- a/bittensor/utils/register_cuda.py
+++ b/bittensor/utils/registration/register_cuda.py
@@ -1,24 +1,8 @@
-# The MIT License (MIT)
-# Copyright © 2024 Opentensor Foundation
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
-# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
-# the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
+"""This module provides functions for solving Proof of Work (PoW) problems using CUDA."""
import binascii
import hashlib
import io
-import math
from contextlib import redirect_stdout
from typing import Any, Union
@@ -26,6 +10,38 @@
from Crypto.Hash import keccak
+def _hex_bytes_to_u8_list(hex_bytes: bytes) -> list[int]:
+ """
+ Convert a sequence of bytes in hexadecimal format to a list of
+ unsigned 8-bit integers.
+
+ Args:
+ hex_bytes (bytes): A sequence of bytes in hexadecimal format.
+
+ Returns:
+ A list of unsigned 8-bit integers.
+
+ """
+ return [int(hex_bytes[i : i + 2], 16) for i in range(0, len(hex_bytes), 2)]
+
+
+def _create_seal_hash(block_and_hotkey_hash_hex_: bytes, nonce: int) -> bytes:
+ """Creates a seal hash from the block and hotkey hash and nonce."""
+ nonce_bytes = binascii.hexlify(nonce.to_bytes(8, "little"))
+ pre_seal = nonce_bytes + block_and_hotkey_hash_hex_
+ seal_sh256 = hashlib.sha256(bytearray(_hex_bytes_to_u8_list(pre_seal))).digest()
+ kec = keccak.new(digest_bits=256)
+ return kec.update(seal_sh256).digest()
+
+
+def _seal_meets_difficulty(seal_: bytes, difficulty: int, limit: int) -> bool:
+ """Checks if the seal meets the given difficulty."""
+ seal_number = int.from_bytes(seal_, "big")
+ product = seal_number * difficulty
+ # limit = int(math.pow(2, 256)) - 1
+ return product < limit
+
+
def solve_cuda(
nonce_start: "np.int64",
update_interval: "np.int64",
@@ -62,29 +78,6 @@ def solve_cuda(
upper_bytes = upper.to_bytes(32, byteorder="little", signed=False)
- def _hex_bytes_to_u8_list(hex_bytes: bytes):
- """Converts a sequence of hex bytes to a list of unsigned 8-bit integers."""
- hex_chunks = [
- int(hex_bytes[i : i + 2], 16) for i in range(0, len(hex_bytes), 2)
- ]
- return hex_chunks
-
- def _create_seal_hash(block_and_hotkey_hash_hex_: bytes, nonce: int) -> bytes:
- """Creates a seal hash from the block and hotkey hash and nonce."""
- nonce_bytes = binascii.hexlify(nonce.to_bytes(8, "little"))
- pre_seal = nonce_bytes + block_and_hotkey_hash_hex_
- seal_sh256 = hashlib.sha256(bytearray(_hex_bytes_to_u8_list(pre_seal))).digest()
- kec = keccak.new(digest_bits=256)
- return kec.update(seal_sh256).digest()
-
- def _seal_meets_difficulty(seal_: bytes, difficulty_: int):
- """Checks if the seal meets the given difficulty."""
- seal_number = int.from_bytes(seal_, "big")
- product = seal_number * difficulty_
- limit_ = int(math.pow(2, 256)) - 1
-
- return product < limit_
-
# Call cython function
# int blockSize, uint64 nonce_start, uint64 update_interval, const unsigned char[:] limit,
# const unsigned char[:] block_bytes, int dev_id
@@ -101,7 +94,7 @@ def _seal_meets_difficulty(seal_: bytes, difficulty_: int):
seal = None
if solution != -1:
seal = _create_seal_hash(block_and_hotkey_hash_hex, solution)
- if _seal_meets_difficulty(seal, difficulty):
+ if _seal_meets_difficulty(seal, difficulty, limit):
return solution, seal
else:
return -1, b"\x00" * 32
diff --git a/bittensor/utils/weight_utils.py b/bittensor/utils/weight_utils.py
index feb281a04c..dc31184476 100644
--- a/bittensor/utils/weight_utils.py
+++ b/bittensor/utils/weight_utils.py
@@ -18,7 +18,6 @@
"""Conversion for weight between chain representation and np.array or torch.Tensor"""
import hashlib
-import logging
import typing
from typing import Union, Optional
@@ -256,10 +255,10 @@ def process_weights_for_netuid(
"""
logging.debug("process_weights_for_netuid()")
- logging.debug("weights", *weights)
- logging.debug("netuid", netuid)
- logging.debug("subtensor", subtensor)
- logging.debug("metagraph", metagraph)
+ logging.debug(f"weights: {weights}")
+ logging.debug(f"netuid {netuid}")
+ logging.debug(f"subtensor: {subtensor}")
+ logging.debug(f"metagraph: {metagraph}")
# Get latest metagraph from chain if metagraph is None.
if metagraph is None:
@@ -278,9 +277,9 @@ def process_weights_for_netuid(
quantile = exclude_quantile / U16_MAX
min_allowed_weights = subtensor.min_allowed_weights(netuid=netuid)
max_weight_limit = subtensor.max_weight_limit(netuid=netuid)
- logging.debug("quantile", quantile)
- logging.debug("min_allowed_weights", min_allowed_weights)
- logging.debug("max_weight_limit", max_weight_limit)
+ logging.debug(f"quantile: {quantile}")
+ logging.debug(f"min_allowed_weights: {min_allowed_weights}")
+ logging.debug(f"max_weight_limit: {max_weight_limit}")
# Find all non zero weights.
non_zero_weight_idx = (
@@ -298,7 +297,7 @@ def process_weights_for_netuid(
if use_torch()
else np.ones((metagraph.n), dtype=np.int64) / metagraph.n
)
- logging.debug("final_weights", *final_weights)
+ logging.debug(f"final_weights: {final_weights}")
final_weights_count = (
torch.tensor(list(range(len(final_weights))))
if use_torch()
@@ -321,7 +320,7 @@ def process_weights_for_netuid(
else np.ones((metagraph.n), dtype=np.int64) * 1e-5
) # creating minimum even non-zero weights
weights[non_zero_weight_idx] += non_zero_weights
- logging.debug("final_weights", *weights)
+ logging.debug(f"final_weights: {weights}")
normalized_weights = normalize_max_weight(x=weights, limit=max_weight_limit)
nw_arange = (
torch.tensor(list(range(len(normalized_weights))))
@@ -330,7 +329,7 @@ def process_weights_for_netuid(
)
return nw_arange, normalized_weights
- logging.debug("non_zero_weights", *non_zero_weights)
+ logging.debug(f"non_zero_weights: {non_zero_weights}")
# Compute the exclude quantile and find the weights in the lowest quantile
max_exclude = max(0, len(non_zero_weights) - min_allowed_weights) / len(
@@ -342,21 +341,21 @@ def process_weights_for_netuid(
if use_torch()
else np.quantile(non_zero_weights, exclude_quantile)
)
- logging.debug("max_exclude", max_exclude)
- logging.debug("exclude_quantile", exclude_quantile)
- logging.debug("lowest_quantile", lowest_quantile)
+ logging.debug(f"max_exclude: {max_exclude}")
+ logging.debug(f"exclude_quantile: {exclude_quantile}")
+ logging.debug(f"lowest_quantile: {lowest_quantile}")
# Exclude all weights below the allowed quantile.
non_zero_weight_uids = non_zero_weight_uids[lowest_quantile <= non_zero_weights]
non_zero_weights = non_zero_weights[lowest_quantile <= non_zero_weights]
- logging.debug("non_zero_weight_uids", *non_zero_weight_uids)
- logging.debug("non_zero_weights", *non_zero_weights)
+ logging.debug(f"non_zero_weight_uids: {non_zero_weight_uids}")
+ logging.debug(f"non_zero_weights: {non_zero_weights}")
# Normalize weights and return.
normalized_weights = normalize_max_weight(
x=non_zero_weights, limit=max_weight_limit
)
- logging.debug("final_weights", *normalized_weights)
+ logging.debug(f"final_weights: {normalized_weights}")
return non_zero_weight_uids, normalized_weights
diff --git a/contrib/CONTRIBUTING.md b/contrib/CONTRIBUTING.md
index f9f4ed5f34..b27b426a09 100644
--- a/contrib/CONTRIBUTING.md
+++ b/contrib/CONTRIBUTING.md
@@ -35,7 +35,7 @@ Bittensor is still in the Alpha stages, and as such you will likely run into som
Additionally, note that the core implementation of Bittensor consists of two separate repositories: [The core Bittensor code](https://github.com/opentensor/bittensor) and the Bittensor Blockchain [subtensor](https://github.com/opentensor/subtensor).
-Supplemental repository for the Bittensor subnet template can be found [here](https://github.com/opentensor/bittensor-subnet-template). This is a great first place to look for getting your hands dirty and started learning and building on Bittensor. See the subnet links [page](https://github.com/opentensor/bittensor-subnet-template/blob/main/subnet_links.json) for a list of all the repositories for the active registered subnets.
+Supplemental repository for the Bittensor subnet template can be found [here](https://github.com/opentensor/bittensor-subnet-template). This is a great first place to look for getting your hands dirty and start learning and building on Bittensor. See the subnet links [page](https://github.com/opentensor/bittensor-subnet-template/blob/main/subnet_links.json) for a list of all the repositories for the active registered subnets.
## Getting Started
New contributors are very welcome and needed.
@@ -43,7 +43,7 @@ Reviewing and testing is highly valued and the most effective way you can contri
Before you start contributing, familiarize yourself with the Bittensor Core build system and tests. Refer to the documentation in the repository on how to build Bittensor core and how to run the unit tests, functional tests.
-There are many open issues of varying difficulty waiting to be fixed. If you're looking for somewhere to start contributing, check out the [good first issue](https://github.com/opentensor/bittensor/labels/good%20first%20issue) list or changes that are up for grabs. Some of them might no longer be applicable. So if you are interested, but unsure, you might want to leave a comment on the issue first. Also peruse the [issues](https://github.com/opentensor/bittensor/issues) tab for all open issues.
+There are many open issues of varying difficulty waiting to be fixed. If you're looking for somewhere to start contributing, check out the [good first issue](https://github.com/opentensor/bittensor/labels/good%20first%20issue) list or changes that are up for grabs. Some of them might no longer be applicable. So if you are interested, but unsure, you might want to leave a comment on the issue first. Also peruse the [issues](https://github.com/opentensor/bittensor/issues) tab for all open issues.
### Good First Issue Label
The purpose of the good first issue label is to highlight which issues are suitable for a new contributor without a deep understanding of the codebase.
@@ -264,7 +264,7 @@ Provide more context by answering these questions:
Include details about your configuration and environment:
-* **Which version of Bittensor are you using?** You can get the version by checking for `__version__` in [`bittensor/bittensor/__init.py`](https://github.com/opentensor/bittensor/blob/master/bittensor/__init__.py#L30). This is not sufficient. Also add the commit hash of the branch you are on.
+* **Which version of Bittensor are you using?** You can get the version by checking for `__version__` in [`bittensor/bittensor/__init.py`](https://github.com/opentensor/bittensor/blob/master/bittensor/__init__.py#L30). This is not sufficient. Also add the commit hash of the branch you are on.
* **What commit hash are you on?** You can get the exact commit hash by checking `git log` and pasting the full commit hash.
* **What's the name and version of the OS you're using**?
* **Are you running Bittensor in a virtual machine?** If so, which VM software are you using and which operating systems and versions are used for the host and the guest?
@@ -282,7 +282,7 @@ When you are creating an enhancement suggestion, please [include as many details
* **Check the [debugging guide](./DEBUGGING.md).** for tips — you might discover that the enhancement is already available. Most importantly, check if you're using the latest version of Bittensor by pulling the latest changes from the Master branch and if you can get the desired behavior by changing [Bittensor's config settings](https://opentensor.github.io/getting-started/configuration.html).
* **Determine which repository the problem should be reported in: if it has to do with your ML model, then it's likely [Bittensor](https://github.com/opentensor/bittensor). If you are having problems with your emissions or Blockchain, then it is in [subtensor](https://github.com/opentensor/subtensor)
-#### How Submit A (Good) Feature Suggestion
+#### How To Submit A (Good) Feature Suggestion
Enhancement suggestions are tracked as [GitHub issues](https://guides.github.com/features/issues/). After you've determined which repository ([Bittensor](https://github.com/opentensor/bittensor) or [subtensor](https://github.com/opentensor/subtensor)) your enhancement suggestion is related to, create an issue on that repository and provide the following information:
diff --git a/contrib/DEBUGGING.md b/contrib/DEBUGGING.md
index 093e3432bf..22013abcb8 100644
--- a/contrib/DEBUGGING.md
+++ b/contrib/DEBUGGING.md
@@ -135,7 +135,7 @@ import pdb; pdb.set_trace() # breakpoint!
This will stop execution at the breakpoint you set and can operate on the stack directly in the terminal.
## Searching for strings
-Use `ag`. It's fast, convenient, and widely available on unix systems. Ag will highlight all occurnaces of a given pattern.
+Use `ag`. It's fast, convenient, and widely available on unix systems. Ag will highlight all occurrences of a given pattern.
```bash
apt-get install silversearcher-ag
diff --git a/contrib/RELEASE_GUIDELINES.md b/contrib/RELEASE_GUIDELINES.md
index d6bda7c860..74658624d8 100644
--- a/contrib/RELEASE_GUIDELINES.md
+++ b/contrib/RELEASE_GUIDELINES.md
@@ -30,12 +30,12 @@ If you are new in this role, ask for the proper setup you need to run this proce
Options:
- -U, --update: type of update. It could be major, minor, patch or rc (release candidate).
- - -A, --apply: This specify to apply the release. Without this the versioning will just show a dry run with no changes.
+ - -A, --apply: This specifies to apply the release. Without this the versioning will just show a dry run with no changes.
## Release script usage
Options:
- - -A, --apply: This specify to apply the release. Without this the release will just show a dry run with no changes.
+ - -A, --apply: This specifies to apply the release. Without this the release will just show a dry run with no changes.
- -T,--github-token: A github personal access token to interact with the Github API.
### Github token
@@ -84,4 +84,4 @@ After a Bittensor release we have to
1. Updating the [Dockerfile](https://github.com/opentensor/cubit/blob/master/docker/Dockerfile)
1. Building its docker image (follow its README instructions)
1. Push it to hub.docker.com
- 1. The generated name will be the same but with `-cubit` in its name
\ No newline at end of file
+ 1. The generated name will be the same but with `-cubit` in its name
diff --git a/contrib/STYLE.md b/contrib/STYLE.md
index 7804359d22..13558ac9e4 100644
--- a/contrib/STYLE.md
+++ b/contrib/STYLE.md
@@ -58,7 +58,7 @@ Python's official style guide is PEP 8, which provides conventions for writing c
#### More details
-Use [`ruff` to format](https://docs.astral.sh/ruff/formatter/#the-ruff-formatter) your python code before commiting for consistency across such a large pool of contributors.
+Use [`ruff` to format](https://docs.astral.sh/ruff/formatter/#the-ruff-formatter) your python code before committing for consistency across such a large pool of contributors.
Black code [style](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#code-style) ensures consistent and opinionated code formatting.
Ruff automatically formats your Python code according to the Black style guide, enhancing code readability and maintainability.
@@ -155,7 +155,7 @@ For example:
Fix typo in introduction to user guide
-Nothing more need be said; if the reader wonders what the typo was, she can simply take a look at the change itself, i.e. use git show or git diff or git log -p.
+Nothing more needs to be said; if the reader wonders what the typo was, she can simply take a look at the change itself, i.e. use git show or git diff or git log -p.
If you’re committing something like this at the command line, it’s easy to use the -m option to git commit:
@@ -197,7 +197,7 @@ Imperative mood just means “spoken or written as if giving a command or instru
Close the door
Take out the trash
-Each of the seven rules you’re reading about right now are written in the imperative (“Wrap the body at 72 characters”, etc.).
+Each of the seven rules you’re reading about right now is written in the imperative (“Wrap the body at 72 characters”, etc.).
The imperative can sound a little rude; that’s why we don’t often use it. But it’s perfect for Git commit subject lines. One reason for this is that Git itself uses the imperative whenever it creates a commit on your behalf.
diff --git a/requirements/prod.txt b/requirements/prod.txt
index 1f3628e1a0..c34618ff49 100644
--- a/requirements/prod.txt
+++ b/requirements/prod.txt
@@ -2,7 +2,6 @@ wheel
setuptools~=70.0.0
aiohttp~=3.9
async-property==0.2.2
-backoff
bittensor-cli
bt-decode==0.2.0a0
colorama~=0.4.6
@@ -24,5 +23,5 @@ python-Levenshtein
scalecodec==1.2.11
substrate-interface~=1.7.9
uvicorn
-websockets>12.0
-bittensor-wallet>=2.1.0
+websockets>=14.1
+bittensor-wallet>=2.1.3
diff --git a/scripts/environments/README.md b/scripts/environments/README.md
deleted file mode 100644
index 0caa0d2ae4..0000000000
--- a/scripts/environments/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-## 04 Installation on Apple M chip
-There are quite a few Python libraries that are not yet compatible with Apple M chipset architecture. The best way to use Bittensor on this hardware is through Conda and Miniforge. The Opentensor team has created a Conda environment that makes installing Bittensor on these systems very easy.
-
-> NOTE: This tutorial assumes you have installed conda on mac, if you have not done so already you can install it from [here](https://conda.io/projects/conda/en/latest/user-guide/install/macos.html).
-
-1. Create the conda environment from the `apple_m1_environment.yml` file here:
- ```bash
- conda env create -f apple_m1_environment.yml
- ```
-
-2. Activate the new environment: `conda activate bittensor`.
-3. Verify that the new environment was installed correctly:
- ```bash
- conda env list
- ```
-
-4. Install bittensor (without dependencies):
- ```bash
- conda activate bittensor # activate the env
- pip install --no-deps bittensor # install bittensor
- ```
diff --git a/scripts/environments/apple_m1_environment.yml b/scripts/environments/apple_m1_environment.yml
deleted file mode 100644
index 7d949c7e4e..0000000000
--- a/scripts/environments/apple_m1_environment.yml
+++ /dev/null
@@ -1,271 +0,0 @@
-name: bittensor
-channels:
- - conda-forge
-dependencies:
- - anyio=3.6.2=pyhd8ed1ab_0
- - appnope=0.1.3=pyhd8ed1ab_0
- - argon2-cffi=21.3.0=pyhd8ed1ab_0
- - argon2-cffi-bindings=21.2.0=py310h8e9501a_3
- - asttokens=2.2.1=pyhd8ed1ab_0
- - async-lru=2.0.2=pyhd8ed1ab_0
- - attrs=23.1.0=pyh71513ae_1
- - babel=2.12.1=pyhd8ed1ab_1
- - backcall=0.2.0=pyh9f0ad1d_0
- - backports=1.0=pyhd8ed1ab_3
- - backports.functools_lru_cache=1.6.4=pyhd8ed1ab_0
- - beautifulsoup4=4.12.2=pyha770c72_0
- - bleach=6.0.0=pyhd8ed1ab_0
- - brotli=1.0.9=h1a8c8d9_8
- - brotli-bin=1.0.9=h1a8c8d9_8
- - bzip2=1.0.8=h3422bc3_4
- - c-ares=1.18.1=h3422bc3_0
- - ca-certificates=2023.5.7=hf0a4a13_0
- - cffi=1.15.1=py310h2399d43_3
- - charset-normalizer=3.1.0=pyhd8ed1ab_0
- - comm=0.1.3=pyhd8ed1ab_0
- - debugpy=1.6.7=py310h0f1eb42_0
- - decorator=5.1.1=pyhd8ed1ab_0
- - defusedxml=0.7.1=pyhd8ed1ab_0
- - entrypoints=0.4=pyhd8ed1ab_0
- - executing=1.2.0=pyhd8ed1ab_0
- - flit-core=3.9.0=pyhd8ed1ab_0
- - gmp=6.2.1=h9f76cd9_0
- - grpcio=1.42.0=py310h00ca444_0
- - importlib-metadata=6.6.0=pyha770c72_0
- - importlib_metadata=6.6.0=hd8ed1ab_0
- - importlib_resources=5.12.0=pyhd8ed1ab_0
- - ipython=8.13.2=pyhd1c38e8_0
- - jedi=0.18.2=pyhd8ed1ab_0
- - json5=0.9.5=pyh9f0ad1d_0
- - jupyter-lsp=2.1.0=pyhd8ed1ab_0
- - jupyter_client=8.2.0=pyhd8ed1ab_0
- - jupyter_core=5.3.0=py310hbe9552e_0
- - jupyter_events=0.6.3=pyhd8ed1ab_0
- - jupyter_server=2.5.0=pyhd8ed1ab_0
- - jupyter_server_terminals=0.4.4=pyhd8ed1ab_1
- - jupyterlab=4.0.0=pyhd8ed1ab_1
- - jupyterlab_pygments=0.2.2=pyhd8ed1ab_0
- - jupyterlab_server=2.22.1=pyhd8ed1ab_0
- - libabseil=20230125.0=cxx17_hb7217d7_1
- - libbrotlicommon=1.0.9=h1a8c8d9_8
- - libbrotlidec=1.0.9=h1a8c8d9_8
- - libbrotlienc=1.0.9=h1a8c8d9_8
- - libcxx=16.0.3=h4653b0c_0
- - libffi=3.4.2=h3422bc3_5
- - libgrpc=1.54.1=h9dbdbd0_0
- - libsodium=1.0.18=h27ca646_1
- - libsqlite=3.41.2=hb31c410_1
- - libzlib=1.2.13=h03a7124_4
- - matplotlib-inline=0.1.6=pyhd8ed1ab_0
- - mistune=2.0.5=pyhd8ed1ab_0
- - nb_conda_kernels=2.3.1=py310hbe9552e_2
- - nbconvert-core=7.4.0=pyhd8ed1ab_0
- - nbformat=5.8.0=pyhd8ed1ab_0
- - ncurses=6.3=h07bb92c_1
- - nest-asyncio=1.5.6=pyhd8ed1ab_0
- - notebook-shim=0.2.3=pyhd8ed1ab_0
- - openssl=3.1.0=h53f4e23_3
- - packaging=23.1=pyhd8ed1ab_0
- - pandocfilters=1.5.0=pyhd8ed1ab_0
- - parso=0.8.3=pyhd8ed1ab_0
- - pexpect=4.8.0=pyh1a96a4e_2
- - pickleshare=0.7.5=py_1003
- - pip=23.1.2=pyhd8ed1ab_0
- - pkgutil-resolve-name=1.3.10=pyhd8ed1ab_0
- - prompt-toolkit=3.0.38=pyha770c72_0
- - prompt_toolkit=3.0.38=hd8ed1ab_0
- - ptyprocess=0.7.0=pyhd3deb0d_0
- - pure_eval=0.2.2=pyhd8ed1ab_0
- - pycparser=2.21=pyhd8ed1ab_0
- - pycryptodome=3.19.0=py310hd71b1c6_1
- - pygments=2.15.1=pyhd8ed1ab_0
- - python-levenshtein=0.12.2=py310he2143c4_1
- - pyobjc-core=9.1.1=py310h44ed3dd_0
- - pyobjc-framework-cocoa=9.1.1=py310h44ed3dd_0
- - pyrsistent=0.19.3=py310h8e9501a_0
- - pysocks=1.7.1=pyha2e5f31_6
- - pytest-asyncio=0.21.0=pyhd8ed1ab_0
- - python=3.10.10=h3ba56d0_0_cpython
- - python-dateutil=2.8.2=pyhd8ed1ab_0
- - python-json-logger=2.0.7=pyhd8ed1ab_0
- - python_abi=3.10=3_cp310
- - pytz=2023.3=pyhd8ed1ab_0
- - pyzmq=25.0.2=py310hc407298_0
- - re2=2023.02.02=hb7217d7_0
- - readline=8.2=h92ec313_1
- - rfc3339-validator=0.1.4=pyhd8ed1ab_0
- - rfc3986-validator=0.1.1=pyh9f0ad1d_0
- - send2trash=1.8.2=pyhd1c38e8_0
- - setuptools=67.7.2=pyhd8ed1ab_0
- - six=1.16.0=pyh6c4a22f_0
- - sniffio=1.3.0=pyhd8ed1ab_0
- - stack_data=0.6.2=pyhd8ed1ab_0
- - terminado=0.17.1=pyhd1c38e8_0
- - tinycss2=1.2.1=pyhd8ed1ab_0
- - tk=8.6.12=he1e0b03_0
- - tomli=2.0.1=pyhd8ed1ab_0
- - traitlets=5.9.0=pyhd8ed1ab_0
- - typing_extensions=4.6.1=pyha770c72_0
- - tzdata=2023c=h71feb2d_0
- - uvicorn=0.22.0=py310hbe9552e_0
- - wcwidth=0.2.6=pyhd8ed1ab_0
- - xz=5.2.6=h57fd34a_0
- - yaml=0.2.5=h3422bc3_2
- - zeromq=4.3.4=hbdafb3b_1
- - zipp=3.15.0=pyhd8ed1ab_0
- - zlib=1.2.13=h03a7124_4
- - pip:
- - addict==2.4.0
- - aiohttp==3.9.0
- - aiosignal==1.3.1
- - altair==4.2.2
- - ansible==6.7.0
- - ansible-core==2.13.7
- - ansible-vault==2.1.0
- - appdirs==1.4.4
- - argparse==1.4.0
- - arrow==1.2.3
- - async-timeout==4.0.2
- - blinker==1.6.2
- - cachetools==4.2.4
- - certifi==2024.2.2
- - cfgv==3.4.0
- - chardet==3.0.4
- - click==8.1.3
- - colorama==0.4.6
- - commonmark==0.9.1
- - cryptography==42.0.5
- - cytoolz==0.12.2
- - dataclasses-json==0.5.13
- - ddt==1.6.0
- - dill==0.3.6
- - distlib==0.3.7
- - docker-pycreds==0.4.0
- - ecdsa==0.18.0
- - eth-hash==0.5.2
- - eth-keys==0.4.0
- - eth-typing==3.4.0
- - eth-utils==2.2.0
- - exceptiongroup==1.1.2
- - fastapi==0.110.1
- - filelock==3.12.2
- - fqdn==1.5.1
- - frozenlist==1.4.0
- - fsspec==2023.6.0
- - fuzzywuzzy==0.18.0
- - gitdb==4.0.10
- - gitpython==3.1.32
- - google-api-core==1.34.0
- - google-api-python-client==2.7.0
- - google-auth==1.35.0
- - google-auth-httplib2==0.1.0
- - googleapis-common-protos==1.59.0
- - grpcio-tools==1.42.0
- - httplib2==0.22.0
- - huggingface-hub==0.16.4
- - hypothesis==6.47.4
- - identify==2.5.26
- - ipykernel==6.26.0
- - ipython-genutils==0.2.0
- - ipywidgets==8.0.6
- - isoduration==20.11.0
- - jinja2==3.1.2
- - joblib==1.2.0
- - jsonpointer==2.3
- - jupyter==1.0.0
- - jupyter-console==6.6.3
- - jupyterlab-widgets==3.0.7
- - markupsafe==2.0.1
- - marshmallow==3.19.0
- - marshmallow-enum==1.5.1
- - more-itertools==10.0.0
- - msgpack-numpy-opentensor==0.5.0
- - multidict==6.0.4
- - multiprocess==0.70.14
- - munch==2.5.0
- - mypy-extensions==1.0.0
- - nbclassic==1.0.0
- - nbclient==0.7.4
- - netaddr==0.8.0
- - networkx==3.1
- - nltk==3.8.1
- - nodeenv==1.8.0
- - notebook==6.5.4
- - numexpr==2.8.4
- - openapi-schema-pydantic==1.2.4
- - password-strength==0.0.3.post2
- - pathtools==0.1.2
- - pillow==10.1.0
- - platformdirs==3.10.0
- - plotly==5.14.1
- - pre-commit==3.3.2
- - prometheus-client==0.14.1
- - promise==2.3
- - py==1.11.0
- - py-bip39-bindings==0.1.11
- - py-ed25519-bindings==1.0.2
- - py-ed25519-zebra-bindings==1.0.1
- - py-sr25519-bindings==0.2.0
- - pyarrow==12.0.1
- - pyasn1==0.5.0
- - pyasn1-modules==0.3.0
- - pydantic==2.7.1
- - pydeck==0.8.1b0
- - pyinstrument==4.4.0
- - pympler==1.0.1
- - pynacl==1.5.0
- - pyparsing==3.1.1
- - python-statemachine==2.1.2
- - pytest==7.4.0
- - qqdm==0.0.7
- - qtconsole==5.4.3
- - qtpy==2.3.1
- - regex==2023.6.3
- - requests==2.31.0
- - resolvelib==0.8.1
- - responses==0.18.0
- - retry==0.9.2
- - rich==12.5.1
- - rsa==4.9
- - scalecodec==1.2.11
- - scikit-learn==1.2.2
- - scipy==1.10.1
- - sentencepiece==0.1.99
- - sentry-sdk==1.28.1
- - setproctitle==1.3.2
- - shortuuid==1.0.11
- - shtab==1.6.5
- - smmap==5.0.0
- - sortedcontainers==2.4.0
- - soupsieve==2.4.1
- - sqlalchemy==2.0.19
- - starlette==0.37.2
- - streamlit==1.22.0
- - substrate-interface==1.7.9
- - tenacity==8.2.2
- - termcolor==2.1.1
- - threadpoolctl==3.1.0
- - tokenizers==0.13.3
- - toml==0.10.2
- - toolz==0.12.0
- - torch==2.0.1
- - torchvision==0.15.2
- - tornado==6.3.3
- - tqdm==4.64.1
- - typing-extensions==4.8.0
- - typing-inspect==0.8.0
- - tzlocal==5.0.1
- - uri-template==1.2.0
- - uritemplate==3.0.1
- - urllib3==1.26.15
- - validators==0.20.0
- - virtualenv==20.24.3
- - wandb==0.15.10
- - webcolors==1.13
- - webencodings==0.5.1
- - websocket-client==1.6.1
- - wheel==0.37.1
- - widgetsnbextension==4.0.7
- - xxhash==3.2.0
- - yarl==1.9.2
-prefix: /opt/homebrew/Caskroom/miniforge/base/envs/bittensor
diff --git a/setup.py b/setup.py
index efc9f926e2..99d5891e12 100644
--- a/setup.py
+++ b/setup.py
@@ -69,6 +69,9 @@ def read_requirements(path):
author="bittensor.com",
packages=find_packages(exclude=["tests", "tests.*"]),
include_package_data=True,
+ package_data={
+ "bittensor": ["utils/certifi.sh"],
+ },
author_email="",
license="MIT",
python_requires=">=3.9",
@@ -86,6 +89,7 @@ def read_requirements(path):
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
"Topic :: Scientific/Engineering",
"Topic :: Scientific/Engineering :: Mathematics",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
diff --git a/tests/e2e_tests/test_axon.py b/tests/e2e_tests/test_axon.py
index a21c4ae532..dd004bb6e3 100644
--- a/tests/e2e_tests/test_axon.py
+++ b/tests/e2e_tests/test_axon.py
@@ -4,9 +4,9 @@
import pytest
import bittensor
+from bittensor.core.subtensor import Subtensor
from bittensor.utils import networking
-from bittensor.utils.btlogging import logging
-from tests.e2e_tests.utils.chain_interactions import register_neuron, register_subnet
+from tests.e2e_tests.utils.chain_interactions import register_subnet
from tests.e2e_tests.utils.e2e_test_utils import (
setup_wallet,
template_path,
@@ -28,12 +28,14 @@ async def test_axon(local_chain):
AssertionError: If any of the checks or verifications fail
"""
- logging.info("Testing test_axon")
+ print("Testing test_axon")
netuid = 1
# Register root as Alice - the subnet owner
alice_keypair, wallet = setup_wallet("//Alice")
+ subtensor = Subtensor(network="ws://localhost:9945")
+
# Register a subnet, netuid 1
assert register_subnet(local_chain, wallet), "Subnet wasn't created"
@@ -43,8 +45,8 @@ async def test_axon(local_chain):
).serialize(), "Subnet wasn't created successfully"
# Register Alice to the network
- assert register_neuron(
- local_chain, wallet, netuid
+ assert subtensor.burned_register(
+ wallet, netuid
), f"Neuron wasn't registered to subnet {netuid}"
metagraph = bittensor.Metagraph(netuid=netuid, network="ws://localhost:9945")
@@ -87,7 +89,7 @@ async def test_axon(local_chain):
stderr=asyncio.subprocess.PIPE,
)
- logging.info("Neuron Alice is now mining")
+ print("Neuron Alice is now mining")
# Waiting for 5 seconds for metagraph to be updated
await asyncio.sleep(5)
@@ -124,4 +126,4 @@ async def test_axon(local_chain):
updated_axon.coldkey == alice_keypair.ss58_address
), "Coldkey mismatch after mining"
- logging.info("✅ Passed test_axon")
+ print("✅ Passed test_axon")
diff --git a/tests/e2e_tests/test_commit_weights.py b/tests/e2e_tests/test_commit_weights.py
index 5c03a3788b..7596004603 100644
--- a/tests/e2e_tests/test_commit_weights.py
+++ b/tests/e2e_tests/test_commit_weights.py
@@ -5,11 +5,9 @@
from bittensor.core.subtensor import Subtensor
from bittensor.utils.balance import Balance
-from bittensor.utils.btlogging import logging
from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
from tests.e2e_tests.utils.chain_interactions import (
add_stake,
- register_neuron,
register_subnet,
sudo_set_hyperparameter_bool,
sudo_set_hyperparameter_values,
@@ -34,7 +32,7 @@ async def test_commit_and_reveal_weights(local_chain):
AssertionError: If any of the checks or verifications fail
"""
netuid = 1
- logging.info("Testing test_commit_and_reveal_weights")
+ print("Testing test_commit_and_reveal_weights")
# Register root as Alice
keypair, alice_wallet = setup_wallet("//Alice")
assert register_subnet(local_chain, alice_wallet), "Unable to register the subnet"
@@ -44,8 +42,11 @@ async def test_commit_and_reveal_weights(local_chain):
"SubtensorModule", "NetworksAdded", [1]
).serialize(), "Subnet wasn't created successfully"
- assert register_neuron(
- local_chain, alice_wallet, netuid
+ subtensor = Subtensor(network="ws://localhost:9945")
+
+ # Register Alice to the subnet
+ assert subtensor.burned_register(
+ alice_wallet, netuid
), "Unable to register Alice as a neuron"
# Stake to become to top neuron after the first epoch
@@ -60,7 +61,6 @@ async def test_commit_and_reveal_weights(local_chain):
netuid,
), "Unable to enable commit reveal on the subnet"
- subtensor = Subtensor(network="ws://localhost:9945")
assert subtensor.get_subnet_hyperparameters(
netuid=netuid,
).commit_reveal_weights_enabled, "Failed to enable commit/reveal"
@@ -169,4 +169,4 @@ async def test_commit_and_reveal_weights(local_chain):
assert (
weight_vals[0] == revealed_weights.value[0][1]
), f"Incorrect revealed weights. Expected: {weights[0]}, Actual: {revealed_weights.value[0][1]}"
- logging.info("✅ Passed test_commit_and_reveal_weights")
+ print("✅ Passed test_commit_and_reveal_weights")
diff --git a/tests/e2e_tests/test_dendrite.py b/tests/e2e_tests/test_dendrite.py
index 24484f68d3..ee4dc745c5 100644
--- a/tests/e2e_tests/test_dendrite.py
+++ b/tests/e2e_tests/test_dendrite.py
@@ -8,7 +8,6 @@
from bittensor.utils.balance import Balance
from bittensor.utils.btlogging import logging
from tests.e2e_tests.utils.chain_interactions import (
- register_neuron,
register_subnet,
add_stake,
wait_epoch,
@@ -35,7 +34,7 @@ async def test_dendrite(local_chain):
AssertionError: If any of the checks or verifications fail
"""
- logging.info("Testing test_dendrite")
+ logging.console.info("Testing test_dendrite")
netuid = 1
# Register root as Alice - the subnet owner
@@ -52,13 +51,14 @@ async def test_dendrite(local_chain):
# Register Bob
bob_keypair, bob_wallet = setup_wallet("//Bob")
+ subtensor = Subtensor(network="ws://localhost:9945")
+
# Register Bob to the network
- assert register_neuron(
- local_chain, bob_wallet, netuid
- ), f"Neuron wasn't registered to subnet {netuid}"
+ assert subtensor.burned_register(
+ bob_wallet, netuid
+ ), "Unable to register Bob as a neuron"
metagraph = Metagraph(netuid=netuid, network="ws://localhost:9945")
- subtensor = Subtensor(network="ws://localhost:9945")
# Assert one neuron is Bob
assert len(subtensor.neurons(netuid=netuid)) == 1
@@ -113,7 +113,7 @@ async def test_dendrite(local_chain):
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
- logging.info("Neuron Alice is now validating")
+ logging.console.info("Neuron Alice is now validating")
await asyncio.sleep(
5
) # wait for 5 seconds for the metagraph and subtensor to refresh with latest data
@@ -133,4 +133,4 @@ async def test_dendrite(local_chain):
assert updated_neuron.coldkey == bob_keypair.ss58_address
assert updated_neuron.pruning_score != 0
- logging.info("✅ Passed test_dendrite")
+ logging.console.info("✅ Passed test_dendrite")
diff --git a/tests/e2e_tests/test_incentive.py b/tests/e2e_tests/test_incentive.py
index e0c6837dc3..ab557a56fd 100644
--- a/tests/e2e_tests/test_incentive.py
+++ b/tests/e2e_tests/test_incentive.py
@@ -3,10 +3,9 @@
import pytest
-from bittensor import Subtensor, logging
+from bittensor.core.subtensor import Subtensor
from tests.e2e_tests.utils.chain_interactions import (
add_stake,
- register_neuron,
register_subnet,
wait_epoch,
)
@@ -38,7 +37,7 @@ async def test_incentive(local_chain):
AssertionError: If any of the checks or verifications fail
"""
- logging.info("Testing test_incentive")
+ print("Testing test_incentive")
netuid = 1
# Register root as Alice - the subnet owner and validator
@@ -53,13 +52,18 @@ async def test_incentive(local_chain):
# Register Bob as miner
bob_keypair, bob_wallet = setup_wallet("//Bob")
+ subtensor = Subtensor(network="ws://localhost:9945")
+
# Register Alice as a neuron on the subnet
- register_neuron(local_chain, alice_wallet, netuid)
+ assert subtensor.burned_register(
+ alice_wallet, netuid
+ ), "Unable to register Alice as a neuron"
# Register Bob as a neuron on the subnet
- register_neuron(local_chain, bob_wallet, netuid)
+ assert subtensor.burned_register(
+ bob_wallet, netuid
+ ), "Unable to register Bob as a neuron"
- subtensor = Subtensor(network="ws://localhost:9945")
# Assert two neurons are in network
assert (
len(subtensor.neurons(netuid=netuid)) == 2
@@ -95,7 +99,7 @@ async def test_incentive(local_chain):
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
- logging.info("Neuron Bob is now mining")
+ print("Neuron Bob is now mining")
await asyncio.sleep(
5
) # wait for 5 seconds for the metagraph to refresh with latest data
@@ -127,7 +131,7 @@ async def test_incentive(local_chain):
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
- logging.info("Neuron Alice is now validating")
+ print("Neuron Alice is now validating")
await asyncio.sleep(
5
) # wait for 5 seconds for the metagraph and subtensor to refresh with latest data
@@ -163,7 +167,7 @@ async def test_incentive(local_chain):
wait_for_finalization=True,
period=5 * FAST_BLOCKS_SPEEDUP_FACTOR,
)
- logging.info("Alice neuron set weights successfully")
+ print("Alice neuron set weights successfully")
await wait_epoch(subtensor)
@@ -183,4 +187,4 @@ async def test_incentive(local_chain):
assert alice_neuron.stake.tao == 10_000.0
assert alice_neuron.validator_trust == 1
- logging.info("✅ Passed test_incentive")
+ print("✅ Passed test_incentive")
diff --git a/tests/e2e_tests/test_liquid_alpha.py b/tests/e2e_tests/test_liquid_alpha.py
index 4725704f61..5f8f15cde6 100644
--- a/tests/e2e_tests/test_liquid_alpha.py
+++ b/tests/e2e_tests/test_liquid_alpha.py
@@ -3,7 +3,6 @@
from bittensor.utils.btlogging import logging
from tests.e2e_tests.utils.chain_interactions import (
add_stake,
- register_neuron,
register_subnet,
sudo_set_hyperparameter_bool,
sudo_set_hyperparameter_values,
@@ -35,7 +34,7 @@ def test_liquid_alpha(local_chain):
"""
u16_max = 65535
netuid = 1
- logging.info("Testing test_liquid_alpha_enabled")
+ logging.console.info("Testing test_liquid_alpha_enabled")
# Register root as Alice
keypair, alice_wallet = setup_wallet("//Alice")
@@ -44,16 +43,16 @@ def test_liquid_alpha(local_chain):
# Verify subnet 1 created successfully
assert local_chain.query("SubtensorModule", "NetworksAdded", [1]).serialize()
- # Register a neuron to the subnet
- assert register_neuron(
- local_chain, alice_wallet, netuid
+ # Register a neuron (Alice) to the subnet
+ subtensor = Subtensor(network="ws://localhost:9945")
+ assert subtensor.burned_register(
+ alice_wallet, netuid
), "Unable to register Alice as a neuron"
# Stake to become to top neuron after the first epoch
add_stake(local_chain, alice_wallet, Balance.from_tao(100_000))
# Assert liquid alpha is disabled
- subtensor = Subtensor(network="ws://localhost:9945")
assert (
subtensor.get_subnet_hyperparameters(netuid=netuid).liquid_alpha_enabled
is False
@@ -184,4 +183,4 @@ def test_liquid_alpha(local_chain):
assert (
subtensor.get_subnet_hyperparameters(netuid=1).liquid_alpha_enabled is False
), "Failed to disable liquid alpha"
- logging.info("✅ Passed test_liquid_alpha")
+ logging.console.info("✅ Passed test_liquid_alpha")
diff --git a/tests/e2e_tests/test_metagraph.py b/tests/e2e_tests/test_metagraph.py
index 8999b30358..f06f79a09b 100644
--- a/tests/e2e_tests/test_metagraph.py
+++ b/tests/e2e_tests/test_metagraph.py
@@ -5,7 +5,6 @@
from bittensor.utils.btlogging import logging
from tests.e2e_tests.utils.chain_interactions import (
add_stake,
- register_neuron,
register_subnet,
)
from tests.e2e_tests.utils.e2e_test_utils import (
@@ -48,7 +47,7 @@ def test_metagraph(local_chain):
Raises:
AssertionError: If any of the checks or verifications fail
"""
- logging.info("Testing test_metagraph_command")
+ logging.console.info("Testing test_metagraph_command")
netuid = 1
# Register Alice, Bob, and Dave
@@ -72,8 +71,8 @@ def test_metagraph(local_chain):
assert len(metagraph.uids) == 0, "Metagraph is not empty"
# Register Bob to the subnet
- assert register_neuron(
- local_chain, bob_wallet, netuid
+ assert subtensor.burned_register(
+ bob_wallet, netuid
), "Unable to register Bob as a neuron"
# Refresh the metagraph
@@ -108,8 +107,8 @@ def test_metagraph(local_chain):
metagraph_pre_dave = subtensor.metagraph(netuid=1)
# Register Dave as a neuron
- assert register_neuron(
- local_chain, dave_wallet, netuid
+ assert subtensor.burned_register(
+ dave_wallet, netuid
), "Unable to register Dave as a neuron"
metagraph.sync(subtensor=subtensor)
@@ -175,4 +174,4 @@ def test_metagraph(local_chain):
metagraph.neurons == metagraph_pre_dave.neurons
), "Neurons don't match after save and load"
- logging.info("✅ Passed test_metagraph")
+ logging.console.info("✅ Passed test_metagraph")
diff --git a/tests/e2e_tests/test_neuron_certificate.py b/tests/e2e_tests/test_neuron_certificate.py
new file mode 100644
index 0000000000..807640e74b
--- /dev/null
+++ b/tests/e2e_tests/test_neuron_certificate.py
@@ -0,0 +1,60 @@
+import pytest
+from bittensor.core.subtensor import Subtensor
+from bittensor.core.axon import Axon
+from bittensor.utils.btlogging import logging
+from tests.e2e_tests.utils.chain_interactions import (
+ wait_interval,
+ register_subnet,
+)
+from tests.e2e_tests.utils.e2e_test_utils import (
+ setup_wallet,
+)
+
+
+@pytest.mark.asyncio
+async def test_neuron_certificate(local_chain):
+ """
+ Tests the metagraph
+
+ Steps:
+ 1. Register a subnet through Alice
+ 2. Serve Alice axon with neuron certificate
+ 3. Verify neuron certificate can be retrieved
+ Raises:
+ AssertionError: If any of the checks or verifications fail
+ """
+ logging.info("Testing neuron_certificate")
+ netuid = 1
+
+ # Register root as Alice - the subnet owner and validator
+ alice_keypair, alice_wallet = setup_wallet("//Alice")
+ register_subnet(local_chain, alice_wallet)
+
+ # Verify subnet created successfully
+ assert local_chain.query(
+ "SubtensorModule", "NetworksAdded", [netuid]
+ ).serialize(), "Subnet wasn't created successfully"
+
+ subtensor = Subtensor(network="ws://localhost:9945")
+
+ # Register Alice as a neuron on the subnet
+ assert subtensor.burned_register(
+ alice_wallet, netuid
+ ), "Unable to register Alice as a neuron"
+
+ # Serve Alice's axon with a certificate
+ axon = Axon(wallet=alice_wallet)
+ encoded_certificate = "?FAKE_ALICE_CERT"
+ axon.serve(netuid=netuid, subtensor=subtensor, certificate=encoded_certificate)
+
+ await wait_interval(tempo=1, subtensor=subtensor, netuid=netuid)
+
+ # Verify we are getting the correct certificate
+ assert (
+ subtensor.get_neuron_certificate(
+ netuid=netuid, hotkey=alice_keypair.ss58_address
+ )
+ == encoded_certificate
+ )
+
+ logging.info("✅ Passed test_neuron_certificate")
diff --git a/tests/e2e_tests/test_root_set_weights.py b/tests/e2e_tests/test_root_set_weights.py
new file mode 100644
index 0000000000..e23ccfc05d
--- /dev/null
+++ b/tests/e2e_tests/test_root_set_weights.py
@@ -0,0 +1,207 @@
+import asyncio
+import sys
+import pytest
+
+from bittensor.core.subtensor import Subtensor
+from tests.e2e_tests.utils.chain_interactions import (
+ register_subnet,
+ wait_epoch,
+ sudo_set_hyperparameter_values,
+)
+from bittensor.core.extrinsics.root import _do_set_root_weights
+from tests.e2e_tests.utils.e2e_test_utils import (
+ setup_wallet,
+ template_path,
+ templates_repo,
+)
+
+FAST_BLOCKS_SPEEDUP_FACTOR = 5
+
+"""
+Verifies:
+
+* root_register()
+* neurons()
+* register_subnet()
+* burned_register()
+* immunity_period()
+* tempo()
+* get_uid_for_hotkey_on_subnet()
+* blocks_since_last_update()
+* subnetwork_n()
+* min_allowed_weights()
+* max_weight_limit()
+* weights_rate_limit()
+* root_set_weights()
+* neurons_lite()
+"""
+
+
+@pytest.mark.asyncio
+async def test_root_reg_hyperparams(local_chain):
+ """
+ Test root weights and hyperparameters in the Subtensor network.
+
+ Steps:
+ 1. Register Alice in the root network (netuid=0).
+ 2. Create a new subnet (netuid=1) and register Alice on this subnet using burned registration.
+ 3. Verify that the subnet's `immunity_period` and `tempo` match the default values.
+ 4. Run Alice as a validator in the background.
+ 5. Fetch Alice's UID on the subnet and record the blocks since her last update.
+ 6. Verify that the subnet was created successfully by checking `subnetwork_n`.
+ 7. Verify hyperparameters related to weights: `min_allowed_weights`, `max_weight_limit`, and `weights_rate_limit`.
+ 8. Wait until the next epoch and set root weights for netuids 0 and 1.
+ 9. Verify that the weights are correctly set on the chain.
+ 10. Adjust hyperparameters to allow proof-of-work (PoW) registration.
+ 11. Verify that the `blocks_since_last_update` has incremented.
+ 12. Fetch neurons using `neurons_lite` for the subnet and verify Alice's participation.
+
+ Raises:
+ AssertionError: If any of the checks or verifications fail.
+ """
+
+ print("Testing root register, weights, and hyperparams")
+ netuid = 1
+
+ # Default immunity period & tempo set through the subtensor side
+ default_immunity_period = 5000
+ default_tempo = 360
+
+ # 0.2 for root network, 0.8 for sn 1
+ # Corresponding to [0.2, 0.8]
+ weights = [16384, 65535]
+
+ # Create Alice, SN1 owner and root network member
+ alice_keypair, alice_wallet = setup_wallet("//Alice")
+ subtensor = Subtensor(network="ws://localhost:9945")
+
+ # Register Alice in root network (0)
+ assert subtensor.root_register(alice_wallet)
+
+ # Assert Alice is successfully registered to root
+ alice_root_neuron = subtensor.neurons(netuid=0)[0]
+ assert alice_root_neuron.coldkey == alice_wallet.coldkeypub.ss58_address
+ assert alice_root_neuron.hotkey == alice_wallet.hotkey.ss58_address
+
+ # Create netuid = 1
+ register_subnet(local_chain, alice_wallet)
+
+ # Register Alice as a neuron on the subnet
+ assert subtensor.burned_register(
+ alice_wallet, netuid
+ ), "Unable to register Alice as a neuron"
+
+ # Ensure correct immunity period & tempo is being fetched
+ assert subtensor.immunity_period(netuid=netuid) == default_immunity_period
+ assert subtensor.tempo(netuid=netuid) == default_tempo
+
+ # Prepare to run Alice as validator
+ cmd = " ".join(
+ [
+ f"{sys.executable}",
+ f'"{template_path}{templates_repo}/neurons/validator.py"',
+ "--netuid",
+ str(netuid),
+ "--subtensor.network",
+ "local",
+ "--subtensor.chain_endpoint",
+ "ws://localhost:9945",
+ "--wallet.path",
+ alice_wallet.path,
+ "--wallet.name",
+ alice_wallet.name,
+ "--wallet.hotkey",
+ "default",
+ "--logging.trace",
+ ]
+ )
+
+ # Run Alice as validator in the background
+ await asyncio.create_subprocess_shell(
+ cmd,
+ stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.PIPE,
+ )
+ print("Neuron Alice is now validating")
+ await asyncio.sleep(5) # Wait a bit for chain to process data
+
+ # Fetch uid against Alice's hotkey on sn 1 (it will be 0 as she is the only registered neuron)
+ alice_uid_sn_1 = subtensor.get_uid_for_hotkey_on_subnet(
+ alice_wallet.hotkey.ss58_address, netuid
+ )
+
+ # Fetch the block since last update for the neuron
+ block_since_update = subtensor.blocks_since_last_update(
+ netuid=netuid, uid=alice_uid_sn_1
+ )
+ assert block_since_update is not None
+
+ # Verify subnet created successfully
+ assert local_chain.query(
+ "SubtensorModule", "NetworksAdded", [netuid]
+ ).serialize(), "Subnet wasn't created successfully"
+
+ # Use subnetwork_n hyperparam to check sn creation
+ assert subtensor.subnetwork_n(netuid) == netuid
+ assert subtensor.subnetwork_n(2) is None
+
+ # Ensure correct hyperparams are being fetched regarding weights
+ assert subtensor.min_allowed_weights(netuid=1) is not None
+ assert subtensor.max_weight_limit(netuid=1) is not None
+ assert subtensor.weights_rate_limit(netuid) is not None
+
+ # Wait until next epoch so we can set root weights
+ await wait_epoch(subtensor)
+
+ # Set root weights to root network (0) and sn 1
+ assert _do_set_root_weights(
+ subtensor,
+ wallet=alice_wallet,
+ uids=[0, 1],
+ vals=weights,
+ netuid=0,
+ version_key=0,
+ wait_for_inclusion=True,
+ wait_for_finalization=True,
+ period=5 * FAST_BLOCKS_SPEEDUP_FACTOR,
+ ) == (True, "Successfully set weights.")
+
+ # Query the weights from the chain
+ weights_set = local_chain.query("SubtensorModule", "Weights", [0, 0]).serialize()
+
+ # Assert correct weights were set for root and sn 1
+ assert [val[1] for val in weights_set] == weights
+
+ # Register Bob as miner
+ bob_keypair, bob_wallet = setup_wallet("//Bob")
+
+ # Change hyperparams so we can execute pow_register
+ assert sudo_set_hyperparameter_values(
+ local_chain,
+ alice_wallet,
+ call_function="sudo_set_difficulty",
+ call_params={"netuid": netuid, "difficulty": "1_000_000"},
+ return_error_message=True,
+ )
+
+ assert sudo_set_hyperparameter_values(
+ local_chain,
+ alice_wallet,
+ call_function="sudo_set_network_pow_registration_allowed",
+ call_params={"netuid": netuid, "registration_allowed": True},
+ return_error_message=True,
+ )
+
+ # TODO: Implement
+ # This registers neuron using pow but it doesn't work on fast-blocks - we get stale pow
+ # pow_registration = subtensor.register(bob_wallet, netuid=1)
+
+ # Fetch neuron lite for sn one and assert Alice participation
+ sn_one_neurons = subtensor.neurons_lite(netuid=netuid)
+ assert (
+ sn_one_neurons[alice_uid_sn_1].coldkey == alice_wallet.coldkeypub.ss58_address
+ )
+ assert sn_one_neurons[alice_uid_sn_1].hotkey == alice_wallet.hotkey.ss58_address
+ assert sn_one_neurons[alice_uid_sn_1].validator_permit is True
+
+ print("✅ Passed root tests")
diff --git a/tests/e2e_tests/test_subtensor_functions.py b/tests/e2e_tests/test_subtensor_functions.py
index d00e587fba..7bcb0863b3 100644
--- a/tests/e2e_tests/test_subtensor_functions.py
+++ b/tests/e2e_tests/test_subtensor_functions.py
@@ -4,9 +4,8 @@
import pytest
from bittensor.core.subtensor import Subtensor
-from bittensor.utils.btlogging import logging
+from bittensor.utils.balance import Balance
from tests.e2e_tests.utils.chain_interactions import (
- register_neuron,
register_subnet,
)
from tests.e2e_tests.utils.e2e_test_utils import (
@@ -15,6 +14,26 @@
templates_repo,
)
+"""
+Verifies:
+
+* get_subnets()
+* get_total_subnets()
+* subnet_exists()
+* get_netuids_for_hotkey()
+* is_hotkey_registered_any()
+* is_hotkey_registered_on_subnet()
+* get_uid_for_hotkey_on_subnet()
+* get_neuron_for_pubkey_and_subnet()
+* get_balance()
+* get_subnet_burn_cost()
+* difficulty()
+* burned_register()
+* recycle()
+* get_existential_deposit()
+* get_all_subnets_info()
+"""
+
@pytest.mark.asyncio
async def test_subtensor_extrinsics(local_chain):
@@ -31,6 +50,10 @@ async def test_subtensor_extrinsics(local_chain):
AssertionError: If any of the checks or verifications fail
"""
netuid = 1
+ # Initial balance for Alice, defined in the genesis file of localnet
+ initial_alice_balance = Balance.from_tao(1_000_000)
+ # Current Existential deposit for all accounts in bittensor
+ existential_deposit = Balance.from_tao(0.000_000_500)
subtensor = Subtensor(network="ws://localhost:9945")
# Subnets 0 and 3 are bootstrapped from the start
@@ -41,9 +64,32 @@ async def test_subtensor_extrinsics(local_chain):
alice_keypair, alice_wallet = setup_wallet("//Alice")
bob_keypair, bob_wallet = setup_wallet("//Bob")
+ # Assert correct balance is fetched for Alice
+ alice_balance = subtensor.get_balance(alice_wallet.coldkeypub.ss58_address)
+ assert (
+ alice_balance == initial_alice_balance
+ ), "Balance for Alice wallet doesn't match with pre-def value"
+
+ # Subnet burn cost is initially lower before we register a subnet
+ pre_subnet_creation_cost = subtensor.get_subnet_burn_cost()
+
# Register subnet
register_subnet(local_chain, alice_wallet), "Unable to register the subnet"
+ # Subnet burn cost is increased immediately after a subnet is registered
+ post_subnet_creation_cost = subtensor.get_subnet_burn_cost()
+
+ # Assert that the burn cost changed after registering a subnet
+ assert Balance.from_tao(pre_subnet_creation_cost) < Balance.from_tao(
+ post_subnet_creation_cost
+ ), "Burn cost did not change after subnet creation"
+
+ # Assert amount is deducted once a subnetwork is registered by Alice
+ alice_balance_post_sn = subtensor.get_balance(alice_wallet.coldkeypub.ss58_address)
+ assert (
+ alice_balance_post_sn + pre_subnet_creation_cost == initial_alice_balance
+ ), "Balance is the same even after registering a subnet"
+
# Subnet 1 is added after registration
assert subtensor.get_subnets() == [0, 1, 3]
assert subtensor.get_total_subnets() == 3
@@ -52,11 +98,25 @@ async def test_subtensor_extrinsics(local_chain):
assert local_chain.query("SubtensorModule", "NetworksAdded", [1]).serialize()
assert subtensor.subnet_exists(netuid)
+ # Default subnetwork difficulty
+ assert (
+ subtensor.difficulty(netuid=1) == 10_000_000
+ ), "Couldn't fetch correct subnet difficulty"
+
# Register Alice to the subnet
- assert register_neuron(
- local_chain, alice_wallet, netuid
+ assert subtensor.burned_register(
+ alice_wallet, netuid
), "Unable to register Alice as a neuron"
+ # Fetch recycle_amount to register to the subnet
+ recycle_amount = subtensor.recycle(netuid=1)
+ alice_balance_post_reg = subtensor.get_balance(alice_wallet.coldkeypub.ss58_address)
+
+ # Ensure recycled amount is only deducted from the balance after registration
+ assert (
+ alice_balance_post_sn - recycle_amount == alice_balance_post_reg
+ ), "Balance for Alice is not correct after burned register"
+
# Verify Alice is registered to netuid 1 and Bob isn't registered to any
assert subtensor.get_netuids_for_hotkey(hotkey_ss58=alice_keypair.ss58_address) == [
1
@@ -90,9 +150,9 @@ async def test_subtensor_extrinsics(local_chain):
), "UID for Alice's hotkey on netuid 1 is not 0 as expected"
# Register Bob to the subnet
- assert register_neuron(
- local_chain, bob_wallet, netuid
- ), "Unable to register Alice as a neuron"
+ assert subtensor.burned_register(
+ bob_wallet, netuid
+ ), "Unable to register Bob as a neuron"
# Verify Bob's UID on netuid 1 is 1
assert (
@@ -133,7 +193,7 @@ async def test_subtensor_extrinsics(local_chain):
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
)
- logging.info("Neuron Alice is now validating")
+ print("Neuron Alice is now validating")
await asyncio.sleep(
5
@@ -148,4 +208,27 @@ async def test_subtensor_extrinsics(local_chain):
neuron_info_old.axon_info != neuron_info.axon_info
), "Neuron info not updated after running validator"
- logging.info("✅ Passed test_subtensor_extrinsics")
+ # Fetch and assert existential deposit for an account in the network
+ assert (
+ subtensor.get_existential_deposit() == existential_deposit
+ ), "Existential deposit value doesn't match with pre-defined value"
+
+ # Fetching all subnets in the network
+ all_subnets = subtensor.get_all_subnets_info()
+
+ # Assert all netuids are present in all_subnets
+ expected_netuids = [0, 1, 3]
+ actual_netuids = [subnet.netuid for subnet in all_subnets]
+ assert (
+ actual_netuids == expected_netuids
+ ), f"Expected netuids {expected_netuids}, but found {actual_netuids}"
+
+ # Assert that the owner_ss58 of subnet 1 matches Alice's coldkey address
+ expected_owner = alice_wallet.coldkeypub.ss58_address
+ subnet_1 = next((subnet for subnet in all_subnets if subnet.netuid == 1), None)
+ actual_owner = subnet_1.owner_ss58
+ assert (
+ actual_owner == expected_owner
+ ), f"Expected owner {expected_owner}, but found {actual_owner}"
+
+ print("✅ Passed test_subtensor_extrinsics")
diff --git a/tests/e2e_tests/test_transfer.py b/tests/e2e_tests/test_transfer.py
index 62cf9723cc..5a18db386e 100644
--- a/tests/e2e_tests/test_transfer.py
+++ b/tests/e2e_tests/test_transfer.py
@@ -1,5 +1,5 @@
-from bittensor import Subtensor, logging
-from bittensor.core.subtensor import transfer_extrinsic
+from bittensor.core.subtensor import Subtensor
+from bittensor.utils.balance import Balance
from tests.e2e_tests.utils.e2e_test_utils import setup_wallet
@@ -10,42 +10,43 @@ def test_transfer(local_chain):
Steps:
1. Create a wallet for Alice
2. Calculate existing balance and transfer 2 Tao
- 3. Calculate balance after extrinsic call and verify calculations
+ 3. Calculate balance after transfer call and verify calculations
Raises:
AssertionError: If any of the checks or verifications fail
"""
- logging.info("Testing test_transfer")
+ print("Testing test_transfer")
# Set up Alice wallet
keypair, wallet = setup_wallet("//Alice")
+ subtensor = Subtensor(network="ws://localhost:9945")
+ transfer_value = Balance.from_tao(2)
+ dest_coldkey = "5GpzQgpiAKHMWNSH3RN4GLf96GVTDct9QxYEFAY7LWcVzTbx"
+
+ # Fetch transfer fee
+ transfer_fee = subtensor.get_transfer_fee(
+ wallet=wallet,
+ dest=dest_coldkey,
+ value=transfer_value,
+ )
# Account details before transfer
- acc_before = local_chain.query("System", "Account", [keypair.ss58_address])
+ balance_before = subtensor.get_balance(wallet.coldkeypub.ss58_address)
- # Transfer Tao using extrinsic
- subtensor = Subtensor(network="ws://localhost:9945")
- transfer_extrinsic(
- subtensor=subtensor,
+ # Transfer Tao
+ assert subtensor.transfer(
wallet=wallet,
- dest="5GpzQgpiAKHMWNSH3RN4GLf96GVTDct9QxYEFAY7LWcVzTbx",
- amount=2,
+ dest=dest_coldkey,
+ amount=transfer_value,
wait_for_finalization=True,
wait_for_inclusion=True,
)
-
# Account details after transfer
- acc_after = local_chain.query("System", "Account", [keypair.ss58_address])
+ balance_after = subtensor.get_balance(wallet.coldkeypub.ss58_address)
- # Transfer calculation assertions
- expected_transfer = 2_000_000_000
- tolerance = 200_000 # Tx fee tolerance
-
- actual_difference = (
- acc_before.value["data"]["free"] - acc_after.value["data"]["free"]
- )
+ # Assert correct transfer calculations
assert (
- expected_transfer <= actual_difference <= expected_transfer + tolerance
- ), f"Expected transfer with tolerance: {expected_transfer} <= {actual_difference} <