feat: era param for set_weights and commit_weights

Author: zyzniewski-reef

bittensor/core/async_subtensor.py

@@ -71,6 +71,11 @@
     set_weights_extrinsic,
     reveal_weights_extrinsic,
 )
+from bittensor.core.extrinsics.options import (
+    DEFAULT_SET_WEIGHTS_EXTRINSIC_ERA,
+    ExtrinsicEra,
+    ExtrinsicEraTypes,
+)
 from bittensor.core.metagraph import AsyncMetagraph
 from bittensor.core.settings import version_as_int, TYPE_REGISTRY
 from bittensor.core.types import ParamWithTypes, SubtensorMixin
@@ -3146,6 +3151,7 @@ async def commit_weights(
         wait_for_inclusion: bool = False,
         wait_for_finalization: bool = False,
         max_retries: int = 5,
+        era: Optional[ExtrinsicEraTypes] = None,
     ) -> tuple[bool, str]:
         """
         Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
@@ -3163,6 +3169,7 @@ async def commit_weights(
             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``.
+            era (ExtrinsicEraTypes, optional): Blocks for which the transaction should be valid.
 
         Returns:
             tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string
@@ -3175,6 +3182,9 @@ async def commit_weights(
         success = False
         message = "No attempt made. Perhaps it is too soon to commit weights!"
 
+        if isinstance(era, dict):
+            era = ExtrinsicEra(**era)
+
         logging.info(
             f"Committing weights with params: netuid={netuid}, uids={uids}, weights={weights}, "
             f"version_key={version_key}"
@@ -3199,6 +3209,7 @@ async def commit_weights(
                     commit_hash=commit_hash,
                     wait_for_inclusion=wait_for_inclusion,
                     wait_for_finalization=wait_for_finalization,
+                    era=era,
                 )
                 if success:
                     break
@@ -3657,6 +3668,7 @@ async def set_weights(
         wait_for_inclusion: bool = False,
         wait_for_finalization: bool = False,
         max_retries: int = 5,
+        era: Optional[ExtrinsicEraTypes] = DEFAULT_SET_WEIGHTS_EXTRINSIC_ERA,
     ):
         """
         Sets the inter-neuronal weights for the specified neuron. This process involves specifying the influence or
@@ -3685,6 +3697,9 @@ async def set_weights(
             contribution are influenced by the weights it sets towards others【81†source】.
         """
 
+        if isinstance(era, dict):
+            era = ExtrinsicEra(**era)
+
         async def _blocks_weight_limit() -> bool:
             bslu, wrl = await asyncio.gather(
                 self.blocks_since_last_update(netuid, uid),
@@ -3724,6 +3739,7 @@ async def _blocks_weight_limit() -> bool:
                     version_key=version_key,
                     wait_for_inclusion=wait_for_inclusion,
                     wait_for_finalization=wait_for_finalization,
+                    era=era if era is not DEFAULT_SET_WEIGHTS_EXTRINSIC_ERA else None,
                 )
                 retries += 1
             return success, message
@@ -3749,6 +3765,7 @@ async def _blocks_weight_limit() -> bool:
                         version_key=version_key,
                         wait_for_inclusion=wait_for_inclusion,
                         wait_for_finalization=wait_for_finalization,
+                        era=era,
                     )
                 except Exception as e:
                     logging.error(f"Error setting weights: {e}")

bittensor/core/extrinsics/asyncex/weights.py

@@ -5,6 +5,7 @@
 import numpy as np
 from numpy.typing import NDArray
 
+from bittensor.core.extrinsics.options import ExtrinsicEra
 import bittensor.utils.weight_utils as weight_utils
 from bittensor.core.settings import version_as_int
 from bittensor.utils import format_error_message
@@ -23,6 +24,7 @@ async def _do_commit_weights(
     commit_hash: str,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, Optional[str]]:
     """
     Internal method to send a transaction to the Bittensor blockchain, committing the hash of a neuron's weights.
@@ -36,6 +38,7 @@ async def _do_commit_weights(
         commit_hash (str): The hash of the neuron's weights to be committed.
         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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         tuple[bool, Optional[str]]: A tuple containing a success flag and an optional error message.
@@ -59,6 +62,7 @@ async def _do_commit_weights(
         use_nonce=True,
         nonce_key="hotkey",
         sign_with="hotkey",
+        period=era.period if era else None,
     )
 
 
@@ -69,6 +73,7 @@ async def commit_weights_extrinsic(
     commit_hash: str,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, str]:
     """
     Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
@@ -82,6 +87,7 @@ async def commit_weights_extrinsic(
         commit_hash (str): The hash of the neuron's weights to be committed.
         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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string
@@ -98,6 +104,7 @@ async def commit_weights_extrinsic(
         commit_hash=commit_hash,
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
+        era=era,
     )
 
     if success:
@@ -231,7 +238,9 @@ async def _do_set_weights(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    period: int = 5,
+    era: ExtrinsicEra = ExtrinsicEra(
+        period=5,
+    ),
 ) -> tuple[bool, Optional[str]]:  # (success, error_message)
     """
     Internal method to send a transaction to the Bittensor blockchain, setting weights
@@ -247,7 +256,7 @@ async def _do_set_weights(
         version_key (int, optional): Version key for compatibility with the network.
         wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block.
         wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain.
-        period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
+        era (ExtrinsicEra, optional): The period in blocks to wait for extrinsic inclusion or finalization. Defaults to 5.
 
     Returns:
         Tuple[bool, Optional[str]]: A tuple containing a success flag and an optional error message.
@@ -271,7 +280,7 @@ async def _do_set_weights(
         wallet,
         wait_for_inclusion,
         wait_for_finalization,
-        period=period,
+        period=era.period if era else None,
         use_nonce=True,
         nonce_key="hotkey",
         sign_with="hotkey",
@@ -287,6 +296,9 @@ async def set_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: ExtrinsicEra = ExtrinsicEra(
+        period=5,
+    ),
 ) -> tuple[bool, str]:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -302,6 +314,7 @@ async def set_weights_extrinsic(
             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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
@@ -331,6 +344,7 @@ async def set_weights_extrinsic(
             version_key=version_key,
             wait_for_finalization=wait_for_finalization,
             wait_for_inclusion=wait_for_inclusion,
+            era=era,
         )
 
         if not wait_for_finalization and not wait_for_inclusion:

bittensor/core/extrinsics/commit_reveal.py

@@ -6,6 +6,7 @@
 import numpy as np
 from numpy.typing import NDArray
 
+from bittensor.core.extrinsics.options import ExtrinsicEra
 from bittensor.core.settings import version_as_int
 from bittensor.utils.btlogging import logging
 from bittensor.utils.weight_utils import convert_weights_and_uids_for_emit
@@ -24,6 +25,7 @@ def _do_commit_reveal_v3(
     reveal_round: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, Optional[str]]:
     """
     Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or
@@ -57,7 +59,12 @@ def _do_commit_reveal_v3(
         },
     )
     return subtensor.sign_and_send_extrinsic(
-        call, wallet, wait_for_inclusion, wait_for_finalization, sign_with="hotkey"
+        call,
+        wallet,
+        wait_for_inclusion,
+        wait_for_finalization,
+        period=era.period if era else None,
+        sign_with="hotkey",
     )
 
 
@@ -70,6 +77,7 @@ def commit_reveal_v3_extrinsic(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, str]:
     """
     Commits and reveals weights for given subtensor and wallet with provided uids and weights.
@@ -124,6 +132,7 @@ def commit_reveal_v3_extrinsic(
             reveal_round=reveal_round,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            era=era,
         )
 
         if success is not True:

bittensor/core/extrinsics/commit_weights.py

@@ -2,6 +2,7 @@
 
 from typing import TYPE_CHECKING, Optional
 
+from bittensor.core.extrinsics.options import ExtrinsicEra
 from bittensor.utils import format_error_message
 from bittensor.utils.btlogging import logging
 
@@ -17,6 +18,7 @@ def _do_commit_weights(
     commit_hash: str,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, Optional[str]]:
     """
     Internal method to send a transaction to the Bittensor blockchain, committing the hash of a neuron's weights.
@@ -29,6 +31,7 @@ def _do_commit_weights(
         commit_hash (str): The hash of the neuron's weights to be committed.
         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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         tuple[bool, Optional[str]]: A tuple containing a success flag and an optional error message.
@@ -52,6 +55,7 @@ def _do_commit_weights(
         use_nonce=True,
         sign_with="hotkey",
         nonce_key="hotkey",
+        period=era.period if era else None,
     )
 
 
@@ -62,6 +66,7 @@ def commit_weights_extrinsic(
     commit_hash: str,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = None,
 ) -> tuple[bool, str]:
     """
     Commits a hash of the neuron's weights to the Bittensor blockchain using the provided wallet.
@@ -74,6 +79,7 @@ def commit_weights_extrinsic(
         commit_hash (str): The hash of the neuron's weights to be committed.
         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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         tuple[bool, str]: ``True`` if the weight commitment is successful, False otherwise. And `msg`, a string
@@ -90,6 +96,7 @@ def commit_weights_extrinsic(
         commit_hash=commit_hash,
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
+        era=era,
     )
 
     if success:

bittensor/core/extrinsics/options.py

@@ -0,0 +1,25 @@
+import dataclasses
+from typing import Union
+
+
+@dataclasses.dataclass(frozen=True)
+class ExtrinsicEra:
+    """
+    Defines blocks for which the transaction should be valid.
+
+    Attributes:
+        period (int): Length (in blocks) for which the transaction should be valid.
+    """
+
+    period: int
+
+
+ExtrinsicEraTypes = Union[
+    dict[str, int],
+    ExtrinsicEra,
+]
+
+
+DEFAULT_SET_WEIGHTS_EXTRINSIC_ERA = ExtrinsicEra(
+    period=5,
+)

bittensor/core/extrinsics/set_weights.py

@@ -1,10 +1,12 @@
 """Module sync setting weights extrinsic."""
 
+import dataclasses
 from typing import Union, TYPE_CHECKING, Optional
 
 import numpy as np
 from numpy.typing import NDArray
 
+from bittensor.core.extrinsics.options import ExtrinsicEra
 from bittensor.core.settings import version_as_int
 from bittensor.utils import format_error_message, weight_utils
 from bittensor.utils.btlogging import logging
@@ -24,7 +26,9 @@ def _do_set_weights(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    period: int = 5,
+    era: Optional[ExtrinsicEra] = ExtrinsicEra(
+        period=5,
+    ),
 ) -> tuple[bool, Optional[str]]:  # (success, error_message)
     """
     Internal method to send a transaction to the Bittensor blockchain, setting weights
@@ -40,7 +44,7 @@ def _do_set_weights(
         version_key (int, optional): Version key for compatibility with the network.
         wait_for_inclusion (bool, optional): Waits for the transaction to be included in a block.
         wait_for_finalization (bool, optional): Waits for the transaction to be finalized on the blockchain.
-        period (int, optional): The period in seconds to wait for extrinsic inclusion or finalization. Defaults to 5.
+        era (ExtrinsicEra, optional): The period in blocks to wait for extrinsic inclusion or finalization. Defaults to 5.
 
     Returns:
         Tuple[bool, Optional[str]]: A tuple containing a success flag and an optional error message.
@@ -64,7 +68,7 @@ def _do_set_weights(
     extrinsic = subtensor.substrate.create_signed_extrinsic(
         call=call,
         keypair=wallet.hotkey,
-        era={"period": period},
+        era=dataclasses.asdict(era) if era else None,
         nonce=next_nonce,
     )
     response = subtensor.substrate.submit_extrinsic(
@@ -91,6 +95,9 @@ def set_weights_extrinsic(
     version_key: int = 0,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
+    era: Optional[ExtrinsicEra] = ExtrinsicEra(
+        period=5,
+    ),
 ) -> tuple[bool, str]:
     """Sets the given weights and values on chain for wallet hotkey account.
 
@@ -106,6 +113,7 @@ def set_weights_extrinsic(
             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.
+        era (ExtrinsicEra, optional): Blocks for which the transaction should be valid.
 
     Returns:
         success (bool): Flag is ``True`` if extrinsic was finalized or included in the block. If we did not wait for
@@ -135,6 +143,7 @@ def set_weights_extrinsic(
             version_key=version_key,
             wait_for_finalization=wait_for_finalization,
             wait_for_inclusion=wait_for_inclusion,
+            era=era,
         )
 
         if not wait_for_finalization and not wait_for_inclusion: