bittensor.utils.registration.pow

bittensor.utils.registration.pow#

This module provides utilities for solving Proof-of-Work (PoW) challenges in Bittensor network.

Attributes#

torch

Classes#

CUDASolver

A process that solves the registration PoW problem.

LazyLoadedTorch

A lazy-loading proxy for the torch module.

POWSolution

A solution to the registration PoW problem.

RegistrationStatistics

Statistics for a registration.

RegistrationStatisticsLogger

Logs statistics for a registration.

Solver

A process that solves the registration PoW problem.

UsingSpawnStartMethod

Functions#

create_pow(subtensor, wallet, netuid[, ...])

Creates a proof of work for the given subtensor and wallet.

get_cpu_count()

Returns the number of CPUs in the system.

legacy_torch_api_compat(func)

Convert function operating on numpy Input&Output to legacy torch Input&Output API if use_torch() is True.

log_no_torch_error()

terminate_workers_and_wait_for_exit(workers)

update_curr_block(curr_diff, curr_block, ...)

Update the current block data with the provided block information and difficulty.

use_torch()

Force the use of torch over numpy for certain operations.

Module Contents#

class bittensor.utils.registration.pow.CUDASolver(proc_num, num_proc, update_interval, finished_queue, solution_queue, stopEvent, curr_block, curr_block_num, curr_diff, check_block, limit, dev_id, tpb)#

Bases: _SolverBase

A process that solves the registration PoW problem.

Parameters:

  • 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.

  • dev_id (int)

  • tpb (int)

dev_id: int#
run()#

Method to be run in sub-process; can be overridden in sub-class

tpb: int#
class bittensor.utils.registration.pow.LazyLoadedTorch#

A lazy-loading proxy for the torch module.

class bittensor.utils.registration.pow.POWSolution#

A solution to the registration PoW problem.

block_number: int#
difficulty: int#
is_stale(subtensor)#

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.

Parameters:

subtensor (bittensor.core.subtensor.Subtensor)

Return type:

bool

async is_stale_async(subtensor)#

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.

Parameters:

subtensor (bittensor.core.async_subtensor.AsyncSubtensor)

Return type:

bool

nonce: int#
seal: bytes#
class bittensor.utils.registration.pow.RegistrationStatistics#

Statistics for a registration.

block_hash: str#
block_number: int#
difficulty: int#
hash_rate: float#
hash_rate_perpetual: float#
rounds_total: int#
time_average: float#
time_spent: float#
time_spent_total: float#
class bittensor.utils.registration.pow.RegistrationStatisticsLogger(console=None, output_in_place=True)#

Logs statistics for a registration.

Parameters:

  • console (Optional[rich.console.Console])

  • output_in_place (bool)

console = None#
classmethod get_status_message(stats, verbose=False)#

Generates the status message based on registration statistics.

Parameters:
Return type:

str

start()#
Return type:

None

status: rich.status.Status | None#
stop()#
Return type:

None

update(stats, verbose=False)#
Parameters:
Return type:

None

class bittensor.utils.registration.pow.Solver(proc_num, num_proc, update_interval, finished_queue, solution_queue, stopEvent, curr_block, curr_block_num, curr_diff, check_block, limit)#

Bases: _SolverBase

A process that solves the registration PoW problem.

Parameters:

  • 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.

run()#

Method to be run in sub-process; can be overridden in sub-class

class bittensor.utils.registration.pow.UsingSpawnStartMethod(force=False)#
Parameters:

force (bool)

bittensor.utils.registration.pow.create_pow(subtensor, wallet, netuid, output_in_place=True, cuda=False, dev_id=0, tpb=256, num_processes=None, update_interval=None, log_verbose=False)#

Creates a proof of work for the given subtensor and wallet.

Parameters:

  • 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:

The proof of work solution or None if the wallet is already registered or there is a

different error.

Return type:

Optional[Dict[str, Any]]

Raises:

ValueError – If the subnet does not exist.

bittensor.utils.registration.pow.get_cpu_count()#

Returns the number of CPUs in the system.

Return type:

int

bittensor.utils.registration.pow.legacy_torch_api_compat(func)#

Convert function operating on numpy Input&Output to legacy torch Input&Output API if use_torch() is True.

Parameters:

func (function) – Function with numpy Input/Output to be decorated.

Returns:

Decorated function.

Return type:

decorated (function)

bittensor.utils.registration.pow.log_no_torch_error()#
bittensor.utils.registration.pow.terminate_workers_and_wait_for_exit(workers)#
Parameters:

workers (list[Union[multiprocessing.Process, multiprocessing.queues.Queue]])

Return type:

None

bittensor.utils.registration.pow.torch#
bittensor.utils.registration.pow.update_curr_block(curr_diff, curr_block, curr_block_num, block_number, block_bytes, diff, hotkey_bytes, 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.

Parameters:

  • curr_diff (multiprocessing.Array) – Shared array to store the current difficulty.

  • curr_block (multiprocessing.Array) – Shared array to store the current block data.

  • curr_block_num (multiprocessing.Value) – Shared value to store the current block number.

  • block_number (int) – The block number to set as the current block number.

  • block_bytes (bytes) – The block data bytes to be hashed with the hotkey.

  • diff (int) – The difficulty value to be packed into the current difficulty array.

  • hotkey_bytes (bytes) – The hotkey bytes used for hashing the block.

  • lock (multiprocessing.Lock) – A lock to ensure thread-safe updates.

bittensor.utils.registration.pow.use_torch()#

Force the use of torch over numpy for certain operations.

Return type:

bool