Add commit-reveal subprocess and related utilities

bittensor/core/chain_data/subnet_hyperparameters.py

@@ -32,7 +32,7 @@ class SubnetHyperparameters:
         max_validators (int): Maximum number of validators.
         adjustment_alpha (int): Alpha value for adjustments.
         difficulty (int): Difficulty level.
-        commit_reveal_weights_interval (int): Interval for commit-reveal weights.
+        commit_reveal_weights_interval (int): Intervals (tempo intervals) for commit-reveal weights.
         commit_reveal_weights_enabled (bool): Flag indicating if commit-reveal weights are enabled.
         alpha_high (int): High value of alpha.
         alpha_low (int): Low value of alpha.

bittensor/core/extrinsics/set_weights.py

@@ -16,6 +16,7 @@
 # DEALINGS IN THE SOFTWARE.
 
 import logging
+import random
 from typing import Union, Optional, TYPE_CHECKING
 
 import numpy as np
@@ -46,11 +47,13 @@ def do_set_weights(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    period: int = 5,
 ) -> tuple[bool, Optional[str]]:  # (success, error_message)
     """
     Internal method to send a transaction to the Bittensor blockchain, setting weights for specified neurons. This method constructs and submits the transaction, handling retries and blockchain communication.
 
     Args:
+        period (int): Period dictates how long the extrinsic will stay as part of waiting pool
         self (bittensor.core.subtensor.Subtensor): Subtensor interface
         wallet (bittensor_wallet.Wallet): The wallet associated with the neuron setting the weights.
         uids (list[int]): List of neuron UIDs for which weights are being set.
@@ -67,26 +70,10 @@ def do_set_weights(
     """
 
     @retry(delay=1, tries=3, backoff=2, max_delay=4)
-    def make_substrate_call_with_retry():
-        call = self.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="set_weights",
-            call_params={
-                "dests": uids,
-                "weights": vals,
-                "netuid": netuid,
-                "version_key": version_key,
-            },
-        )
-        # Period dictates how long the extrinsic will stay as part of waiting pool
-        extrinsic = self.substrate.create_signed_extrinsic(
-            call=call,
-            keypair=wallet.hotkey,
-            era={"period": 5},
-        )
+    def make_substrate_call_with_retry(extrinsic_):
         response = submit_extrinsic(
             substrate=self.substrate,
-            extrinsic=extrinsic,
+            extrinsic=extrinsic_,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
@@ -102,7 +89,23 @@ def make_substrate_call_with_retry():
                 response.error_message, substrate=self.substrate
             )
 
-    return make_substrate_call_with_retry()
+    call = self.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="set_weights",
+        call_params={
+            "dests": uids,
+            "weights": vals,
+            "netuid": netuid,
+            "version_key": version_key,
+        },
+    )
+    # Period dictates how long the extrinsic will stay as part of waiting pool
+    extrinsic = self.substrate.create_signed_extrinsic(
+        call=call,
+        keypair=wallet.hotkey,
+        era={"period": period},
+    )
+    return make_substrate_call_with_retry(extrinsic)
 
 
 # Community uses this extrinsic directly and via `subtensor.set_weights`
@@ -131,51 +134,100 @@ def set_weights_extrinsic(
     Returns:
         tuple[bool, str]: A tuple containing a success flag and an optional response message.
     """
-    # First convert types.
-    if use_torch():
-        if isinstance(uids, list):
-            uids = torch.tensor(uids, dtype=torch.int64)
-        if isinstance(weights, list):
-            weights = torch.tensor(weights, dtype=torch.float32)
-    else:
-        if isinstance(uids, list):
-            uids = np.array(uids, dtype=np.int64)
-        if isinstance(weights, list):
-            weights = np.array(weights, dtype=np.float32)
-
-    # Reformat and normalize.
-    weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit(
-        uids, weights
-    )
+    get_subnet_hyperparameters = subtensor.get_subnet_hyperparameters(netuid=netuid)
+    if (
+        get_subnet_hyperparameters
+        and get_subnet_hyperparameters.commit_reveal_weights_enabled
+    ):
+        # if cr is enabled, commit instead of setting the weights.
+        salt = [random.randint(0, 350) for _ in range(8)]
+
+        logging.info(f":satellite: Committing weights on {subtensor.network}...")
+        try:
+            # First convert types.
+            if use_torch():
+                if isinstance(uids, list):
+                    uids = torch.tensor(uids, dtype=torch.int64)
+                if isinstance(weights, list):
+                    weights = torch.tensor(weights, dtype=torch.float32)
+            else:
+                if isinstance(uids, list):
+                    uids = np.array(uids, dtype=np.int64)
+                if isinstance(weights, list):
+                    weights = np.array(weights, dtype=np.float32)
+
+            # Reformat and normalize.
+            weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit(
+                uids, weights
+            )
 
-    logging.info(
-        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]}")
-
-    try:
-        success, error_message = do_set_weights(
-            self=subtensor,
-            wallet=wallet,
-            netuid=netuid,
-            uids=weight_uids,
-            vals=weight_vals,
-            version_key=version_key,
-            wait_for_finalization=wait_for_finalization,
-            wait_for_inclusion=wait_for_inclusion,
+            success, message = subtensor.commit_weights(
+                wallet=wallet,
+                netuid=netuid,
+                salt=salt,
+                uids=weight_uids,
+                weights=weight_vals,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+            )
+            if not wait_for_finalization and not wait_for_inclusion:
+                return True, "Not waiting for finalization or inclusion."
+
+            if success is True:
+                logging.success(
+                    f"<green>Finalized!</green> Committed weights: {str(success)}"
+                )
+                return True, "Successfully committed weights and Finalized."
+            else:
+                logging.error(message)
+                return False, message
+
+        except Exception as e:
+            logging.error(f":cross_mark: <red>Failed. Error:</red> {e}")
+            return False, str(e)
+    else:
+        # First convert types.
+        if use_torch():
+            if isinstance(uids, list):
+                uids = torch.tensor(uids, dtype=torch.int64)
+            if isinstance(weights, list):
+                weights = torch.tensor(weights, dtype=torch.float32)
+        else:
+            if isinstance(uids, list):
+                uids = np.array(uids, dtype=np.int64)
+            if isinstance(weights, list):
+                weights = np.array(weights, dtype=np.float32)
+
+        # Reformat and normalize.
+        weight_uids, weight_vals = weight_utils.convert_weights_and_uids_for_emit(
+            uids, weights
         )
 
-        if not wait_for_finalization and not wait_for_inclusion:
-            return True, "Not waiting for finalization or inclusion."
-
-        if success is True:
-            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
+        logging.info(f":satellite: Setting weights on {subtensor.network}...")
+        try:
+            success, error_message = do_set_weights(
+                self=subtensor,
+                wallet=wallet,
+                netuid=netuid,
+                uids=weight_uids,
+                vals=weight_vals,
+                version_key=version_key,
+                wait_for_finalization=wait_for_finalization,
+                wait_for_inclusion=wait_for_inclusion,
+            )
 
-    except Exception as e:
-        logging.error(f":cross_mark: <red>Failed.</red>: Error: {e}")
-        logging.debug(str(e))
-        return False, str(e)
+            if not wait_for_finalization and not wait_for_inclusion:
+                return True, "Not waiting for finalization or inclusion."
+
+            if success is True:
+                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: <red>Failed error:</red> {e}")
+            return False, str(e)

bittensor/core/extrinsics/transfer.py

@@ -63,18 +63,10 @@ def do_transfer(
     """
 
     @retry(delay=1, tries=3, backoff=2, max_delay=4)
-    def make_substrate_call_with_retry():
-        call = self.substrate.compose_call(
-            call_module="Balances",
-            call_function="transfer_allow_death",
-            call_params={"dest": dest, "value": transfer_balance.rao},
-        )
-        extrinsic = self.substrate.create_signed_extrinsic(
-            call=call, keypair=wallet.coldkey
-        )
+    def make_substrate_call_with_retry(extrinsic_):
         response = submit_extrinsic(
             substrate=self.substrate,
-            extrinsic=extrinsic,
+            extrinsic=extrinsic_,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
         )
@@ -90,7 +82,15 @@ def make_substrate_call_with_retry():
         else:
             return False, None, response.error_message
 
-    return make_substrate_call_with_retry()
+    call = self.substrate.compose_call(
+        call_module="Balances",
+        call_function="transfer_allow_death",
+        call_params={"dest": dest, "value": transfer_balance.rao},
+    )
+    extrinsic = self.substrate.create_signed_extrinsic(
+        call=call, keypair=wallet.coldkey
+    )
+    return make_substrate_call_with_retry(extrinsic)
 
 
 # Community uses this extrinsic directly and via `subtensor.transfer`