Add period argument to extrinsics calls

bittensor/core/extrinsics/asyncex/commit_reveal.py

@@ -8,7 +8,7 @@
 
 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
+from bittensor.utils.weight_utils import convert_and_normalize_weights_and_uids
 
 if TYPE_CHECKING:
     from bittensor_wallet import Wallet
@@ -24,23 +24,26 @@ async def _do_commit_reveal_v3(
     reveal_round: int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-) -> tuple[bool, Optional[str]]:
+    period: Optional[int] = None,
+) -> tuple[bool, str]:
     """
-    Executes the commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or
-    finalization.
+    Executes commit-reveal phase 3 for a given netuid and commit, and optionally waits for extrinsic inclusion or finalization.
 
     Arguments:
         subtensor: An instance of the AsyncSubtensor class.
         wallet: Wallet An instance of the Wallet class containing the user's keypair.
         netuid: int The network unique identifier.
-        commit  bytes The commit data in bytes format.
+        commit:  bytes The commit data in bytes format.
         reveal_round: int The round number for the reveal phase.
         wait_for_inclusion: bool, optional Flag indicating whether to wait for the extrinsic to be included in a block.
         wait_for_finalization: bool, optional Flag indicating whether to wait for the extrinsic to be finalized.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
+            the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            You can think of it as an expiration date for the transaction.
 
     Returns:
-        A tuple where the first element is a boolean indicating success or failure, and the second element is an
-            optional string containing error message if any.
+        A tuple where the first element is a boolean indicating success or failure, and the second element is a
+            string containing an error message if any.
     """
     logging.info(
         f"Committing weights hash [blue]{commit.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
@@ -57,7 +60,12 @@ async def _do_commit_reveal_v3(
         },
     )
     return await subtensor.sign_and_send_extrinsic(
-        call, wallet, wait_for_inclusion, wait_for_finalization, sign_with="hotkey"
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        sign_with="hotkey",
+        period=period,
     )
 
 
@@ -70,10 +78,11 @@ async def commit_reveal_v3_extrinsic(
     version_key: int = version_as_int,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    block_time: float = 12.0,
+    block_time: Union[int, float] = 12.0,
+    period: Optional[int] = None,
 ) -> tuple[bool, str]:
     """
-    Commits and reveals weights for given subtensor and wallet with provided uids and weights.
+    Commits and reveals weights for a given subtensor and wallet with provided uids and weights.
 
     Arguments:
         subtensor: The AsyncSubtensor instance.
@@ -84,21 +93,17 @@ async def commit_reveal_v3_extrinsic(
         version_key: The version key to use for committing and revealing. Default is version_as_int.
         wait_for_inclusion: Whether to wait for the inclusion of the transaction. Default is False.
         wait_for_finalization: Whether to wait for the finalization of the transaction. Default is False.
-        block_time (float): The amount of seconds for block duration. Default is 12.0 seconds.
+        block_time (float): The number of seconds for block duration. Default is 12.0 seconds.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
+            the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            You can think of it as an expiration date for the transaction.
 
     Returns:
         tuple[bool, str]: A tuple where the first element is a boolean indicating success or failure, and the second
             element is a message associated with the result
     """
     try:
-        # Convert uids and weights
-        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.
-        uids, weights = convert_weights_and_uids_for_emit(uids, weights)
+        uids, weights = convert_and_normalize_weights_and_uids(uids, weights)
 
         current_block = await subtensor.substrate.get_block(None)
         subnet_hyperparameters = await subtensor.get_subnet_hyperparameters(
@@ -127,6 +132,7 @@ async def commit_reveal_v3_extrinsic(
             reveal_round=reveal_round,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success is not True:

bittensor/core/extrinsics/asyncex/move_stake.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from bittensor.utils.balance import Balance
 from bittensor.utils.btlogging import logging
@@ -18,6 +18,7 @@ async def _get_stake_in_origin_and_dest(
     origin_netuid: int,
     destination_netuid: int,
 ) -> tuple[Balance, Balance]:
+    """Gets the current stake balances for both origin and destination addresses in their respective subnets."""
     block_hash = await subtensor.substrate.get_chain_head()
     stake_in_origin, stake_in_destination = await asyncio.gather(
         subtensor.get_stake(
@@ -46,6 +47,7 @@ async def transfer_stake_extrinsic(
     amount: Balance,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Transfers stake from one coldkey to another in the Bittensor network.
@@ -60,6 +62,9 @@ async def transfer_stake_extrinsic(
         amount (Balance): The amount of stake to transfer as a `Balance` object.
         wait_for_inclusion (bool): If True, waits for transaction inclusion in a block. Defaults to `True`.
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to `False`.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
+            the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            You can think of it as an expiration date for the transaction.
 
     Returns:
         bool: True if the transfer was successful, False otherwise.
@@ -77,7 +82,7 @@ async def transfer_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=hotkey_ss58,
         destination_hotkey_ss58=hotkey_ss58,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -116,6 +121,7 @@ async def transfer_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -126,7 +132,7 @@ async def transfer_stake_extrinsic(
 
             # Get updated stakes
             origin_stake, dest_stake = await _get_stake_in_origin_and_dest(
-                subtensor,
+                subtensor=subtensor,
                 origin_hotkey_ss58=hotkey_ss58,
                 destination_hotkey_ss58=hotkey_ss58,
                 origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -163,6 +169,7 @@ async def swap_stake_extrinsic(
     safe_staking: bool = False,
     allow_partial_stake: bool = False,
     rate_tolerance: float = 0.005,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Swaps stake from one subnet to another for a given hotkey in the Bittensor network.
@@ -178,7 +185,10 @@ async def swap_stake_extrinsic(
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to False.
         safe_staking (bool): If true, enables price safety checks to protect against price impact.
         allow_partial_stake (bool): If true, allows partial stake swaps when the full amount would exceed the price tolerance.
-        rate_tolerance (float): Maximum allowed increase in price ratio (0.005 = 0.5%).
+        rate_tolerance (float): Maximum allowed increase in a price ratio (0.005 = 0.5%).
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
+            the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            You can think of it as an expiration date for the transaction.
 
     Returns:
         bool: True if the swap was successful, False otherwise.
@@ -195,7 +205,7 @@ async def swap_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=hotkey_ss58,
         destination_hotkey_ss58=hotkey_ss58,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -259,6 +269,7 @@ async def swap_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -309,6 +320,7 @@ async def move_stake_extrinsic(
     amount: Balance,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = False,
+    period: Optional[int] = None,
 ) -> bool:
     """
     Moves stake from one hotkey to another within subnets in the Bittensor network.
@@ -323,6 +335,9 @@ async def move_stake_extrinsic(
         amount (Balance): The amount of stake to move as a `Balance` object.
         wait_for_inclusion (bool): If True, waits for transaction inclusion in a block. Defaults to True.
         wait_for_finalization (bool): If True, waits for transaction finalization. Defaults to False.
+        period (Optional[int]): The number of blocks during which the transaction will remain valid after it's submitted. If
+            the transaction is not included in a block within that number of blocks, it will expire and be rejected.
+            You can think of it as an expiration date for the transaction.
 
     Returns:
         bool: True if the move was successful, False otherwise.
@@ -331,7 +346,7 @@ async def move_stake_extrinsic(
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(
-        subtensor,
+        subtensor=subtensor,
         origin_hotkey_ss58=origin_hotkey,
         destination_hotkey_ss58=destination_hotkey,
         origin_coldkey_ss58=wallet.coldkeypub.ss58_address,
@@ -369,6 +384,7 @@ async def move_stake_extrinsic(
             wallet=wallet,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
+            period=period,
         )
 
         if success:
@@ -379,7 +395,7 @@ async def move_stake_extrinsic(
 
             # Get updated stakes
             origin_stake, dest_stake = await _get_stake_in_origin_and_dest(
-                subtensor,
+                subtensor=subtensor,
                 origin_hotkey_ss58=origin_hotkey,
                 destination_hotkey_ss58=destination_hotkey,
                 origin_coldkey_ss58=wallet.coldkeypub.ss58_address,