[v10] Standardize extrinsic parameter order

.github/workflows/e2e-subtensor-tests.yaml

@@ -138,6 +138,7 @@ jobs:
       - pull-docker-image
     strategy:
       fail-fast: false
+      max-parallel: 16
       matrix:
         include: ${{ fromJson(needs.find-tests.outputs.test-files) }}
     uses: ./.github/workflows/_run-e2e-single.yaml

bittensor/core/extrinsics/asyncex/children.py

@@ -12,30 +12,31 @@ async def set_children_extrinsic(
     hotkey: str,
     netuid: int,
     children: list[tuple[float, str]],
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
-    raise_error: bool = False,
     period: Optional[int] = None,
-):
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
+) -> tuple[bool, str]:
     """
     Allows a coldkey to set children-keys.
 
-    Arguments:
-        subtensor: bittensor subtensor.
+    Parameters:
+        subtensor: The Subtensor client instance used for blockchain interaction.
         wallet: bittensor wallet instance.
         hotkey: The ``SS58`` address of the neuron's hotkey.
         netuid: The netuid value.
         children: A list of children with their proportions.
-        wait_for_inclusion: Waits for the transaction to be included in a block.
-        wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
-        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
         period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Waits for the transaction to be included in a block.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
 
     Returns:
-        tuple[bool, str]: A tuple where the first element is a boolean indicating success or failure of the operation,
-            and the second element is a message providing additional information.
+        Tuple[bool, str]:
+            - True and a success message if the extrinsic is successfully submitted or processed.
+            - False and an error message if the submission fails or the wallet cannot be unlocked.
 
     Raises:
         DuplicateChild: There are duplicates in the list of children.
@@ -75,10 +76,10 @@ async def set_children_extrinsic(
         success, message = await subtensor.sign_and_send_extrinsic(
             call=call,
             wallet=wallet,
+            period=period,
+            raise_error=raise_error,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
-            raise_error=raise_error,
-            period=period,
         )
 
         if not wait_for_finalization and not wait_for_inclusion:
@@ -94,12 +95,29 @@ async def root_set_pending_childkey_cooldown_extrinsic(
     subtensor: "AsyncSubtensor",
     wallet: "Wallet",
     cooldown: int,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
     period: Optional[int] = None,
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
 ) -> tuple[bool, str]:
     """
-    Allows a coldkey to set children-keys.
+    Allows a root coldkey to set children-keys.
+
+    Parameters:
+        subtensor: The Subtensor client instance used for blockchain interaction.
+        wallet: The wallet used to sign the extrinsic (must be unlocked).
+        cooldown: The cooldown period in blocks.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Waits for the transaction to be included in a block.
+        wait_for_finalization: Waits for the transaction to be finalized on the blockchain.
+
+    Returns:
+        Tuple[bool, str]:
+            - True and a success message if the extrinsic is successfully submitted or processed.
+            - False and an error message if the submission fails or the wallet cannot be unlocked.
     """
     unlock = unlock_key(wallet)
 
@@ -122,9 +140,10 @@ async def root_set_pending_childkey_cooldown_extrinsic(
         success, message = await subtensor.sign_and_send_extrinsic(
             call=sudo_call,
             wallet=wallet,
+            period=period,
+            raise_error=raise_error,
             wait_for_inclusion=wait_for_inclusion,
             wait_for_finalization=wait_for_finalization,
-            period=period,
         )
 
         if not wait_for_finalization and not wait_for_inclusion:

bittensor/core/extrinsics/asyncex/commit_reveal.py

@@ -22,34 +22,37 @@ async def commit_reveal_extrinsic(
     netuid: int,
     uids: Union[NDArray[np.int64], "torch.LongTensor", list],
     weights: Union[NDArray[np.float32], "torch.FloatTensor", list],
+    block_time: Union[int, float] = 12.0,
+    commit_reveal_version: int = 4,
     version_key: int = version_as_int,
+    period: Optional[int] = None,
+    raise_error: bool = False,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-    block_time: Union[int, float] = 12.0,
-    period: Optional[int] = None,
-    commit_reveal_version: int = 4,
 ) -> tuple[bool, str]:
     """
     Commits and reveals weights for a given subtensor and wallet with provided uids and weights.
 
-    Arguments:
-        subtensor: The AsyncSubtensor instance.
+    Parameters:
+        subtensor: The Subtensor instance.
         wallet: The wallet to use for committing and revealing.
         netuid: The id of the network.
         uids: The uids to commit.
         weights: The weights associated with the uids.
-        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 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.
-        commit_reveal_version: The version of the chain commit-reveal protocol to use. Default is ``4``.
+        block_time: The number of seconds for block duration.
+        commit_reveal_version: The version of the chain commit-reveal protocol to use.
+        version_key: The version key to use for committing and revealing.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction.
+        wait_for_finalization: Whether to wait for the finalization of 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
+        Tuple[bool, str]:
+            - True and a success message if the extrinsic is successfully submitted or processed.
+            - False and an error message if the submission fails or the wallet cannot be unlocked.
     """
     try:
         uids, weights = convert_and_normalize_weights_and_uids(uids, weights)
@@ -96,6 +99,7 @@ async def commit_reveal_extrinsic(
             wait_for_finalization=wait_for_finalization,
             sign_with="hotkey",
             period=period,
+            raise_error=raise_error,
         )
 
         if not success:

bittensor/core/extrinsics/asyncex/liquidity.py

@@ -18,34 +18,36 @@ async def add_liquidity_extrinsic(
     price_low: Balance,
     price_high: Balance,
     hotkey: Optional[str] = None,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
     period: Optional[int] = None,
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
 ) -> tuple[bool, str]:
     """
     Adds liquidity to the specified price range.
 
-    Arguments:
+    Parameters:
         subtensor: The Subtensor client instance used for blockchain interaction.
         wallet: The wallet used to sign the extrinsic (must be unlocked).
         netuid: The UID of the target subnet for which the call is being initiated.
         liquidity: The amount of liquidity to be added.
         price_low: The lower bound of the price tick range.
         price_high: The upper bound of the price tick range.
-        hotkey: The hotkey with staked TAO in Alpha. If not passed then the wallet hotkey is used. Defaults to `None`.
-        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block. Defaults to True.
-        wait_for_finalization: Whether to wait for finalization of the extrinsic. Defaults to False.
-        period: 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.
+        hotkey: The hotkey with staked TAO in Alpha. If not passed then the wallet hotkey is used.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction.
+        wait_for_finalization: Whether to wait for the finalization of the transaction.
 
     Returns:
         Tuple[bool, str]:
             - True and a success message if the extrinsic is successfully submitted or processed.
             - False and an error message if the submission fails or the wallet cannot be unlocked.
 
     Note: Adding is allowed even when user liquidity is enabled in specified subnet. Call
-        `toggle_user_liquidity_extrinsic` to enable/disable user liquidity.
+    `toggle_user_liquidity_extrinsic` to enable/disable user liquidity.
     """
     if not (unlock := unlock_key(wallet)).success:
         logging.error(unlock.message)
@@ -73,6 +75,7 @@ async def add_liquidity_extrinsic(
         wait_for_finalization=wait_for_finalization,
         use_nonce=True,
         period=period,
+        raise_error=raise_error,
     )
 
 
@@ -83,24 +86,26 @@ async def modify_liquidity_extrinsic(
     position_id: int,
     liquidity_delta: Balance,
     hotkey: Optional[str] = None,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
     period: Optional[int] = None,
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
 ) -> tuple[bool, str]:
     """Modifies liquidity in liquidity position by adding or removing liquidity from it.
 
-    Arguments:
+    Parameters:
         subtensor: The Subtensor client instance used for blockchain interaction.
         wallet: The wallet used to sign the extrinsic (must be unlocked).
         netuid: The UID of the target subnet for which the call is being initiated.
         position_id: The id of the position record in the pool.
         liquidity_delta: The amount of liquidity to be added or removed (add if positive or remove if negative).
         hotkey: The hotkey with staked TAO in Alpha. If not passed then the wallet hotkey is used. Defaults to `None`.
-        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block. Defaults to True.
-        wait_for_finalization: Whether to wait for finalization of the extrinsic. Defaults to False.
-        period: 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.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction.
+        wait_for_finalization: Whether to wait for the finalization of the transaction.
 
     Returns:
         Tuple[bool, str]:
@@ -132,6 +137,7 @@ async def modify_liquidity_extrinsic(
         wait_for_finalization=wait_for_finalization,
         use_nonce=True,
         period=period,
+        raise_error=raise_error,
     )
 
 
@@ -141,31 +147,33 @@ async def remove_liquidity_extrinsic(
     netuid: int,
     position_id: int,
     hotkey: Optional[str] = None,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
     period: Optional[int] = None,
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
 ) -> tuple[bool, str]:
     """Remove liquidity and credit balances back to wallet's hotkey stake.
 
-    Arguments:
+    Parameters:
         subtensor: The Subtensor client instance used for blockchain interaction.
         wallet: The wallet used to sign the extrinsic (must be unlocked).
         netuid: The UID of the target subnet for which the call is being initiated.
         position_id: The id of the position record in the pool.
         hotkey: The hotkey with staked TAO in Alpha. If not passed then the wallet hotkey is used. Defaults to `None`.
-        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block. Defaults to True.
-        wait_for_finalization: Whether to wait for finalization of the extrinsic. Defaults to False.
-        period: 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.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction.
+        wait_for_finalization: Whether to wait for the finalization of the transaction.
 
     Returns:
         Tuple[bool, str]:
             - True and a success message if the extrinsic is successfully submitted or processed.
             - False and an error message if the submission fails or the wallet cannot be unlocked.
 
-    Note: Adding is allowed even when user liquidity is enabled in specified subnet.
-        Call `toggle_user_liquidity_extrinsic` to enable/disable user liquidity.
+    Note: Adding is allowed even when user liquidity is enabled in specified subnet. Call
+    `toggle_user_liquidity_extrinsic` to enable/disable user liquidity.
     """
     if not (unlock := unlock_key(wallet)).success:
         logging.error(unlock.message)
@@ -188,6 +196,7 @@ async def remove_liquidity_extrinsic(
         wait_for_finalization=wait_for_finalization,
         use_nonce=True,
         period=period,
+        raise_error=raise_error,
     )
 
 
@@ -196,22 +205,24 @@ async def toggle_user_liquidity_extrinsic(
     wallet: "Wallet",
     netuid: int,
     enable: bool,
-    wait_for_inclusion: bool = True,
-    wait_for_finalization: bool = False,
     period: Optional[int] = None,
+    raise_error: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = True,
 ) -> tuple[bool, str]:
     """Allow to toggle user liquidity for specified subnet.
 
-    Arguments:
+    Parameters:
         subtensor: The Subtensor client instance used for blockchain interaction.
         wallet: The wallet used to sign the extrinsic (must be unlocked).
         netuid: The UID of the target subnet for which the call is being initiated.
         enable: Boolean indicating whether to enable user liquidity.
-        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block. Defaults to True.
-        wait_for_finalization: Whether to wait for finalization of the extrinsic. Defaults to False.
-        period: 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.
+        period: 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.
+        raise_error: Raises a relevant exception rather than returning `False` if unsuccessful.
+        wait_for_inclusion: Whether to wait for the inclusion of the transaction.
+        wait_for_finalization: Whether to wait for the finalization of the transaction.
 
     Returns:
         Tuple[bool, str]:
@@ -234,4 +245,5 @@ async def toggle_user_liquidity_extrinsic(
         wait_for_inclusion=wait_for_inclusion,
         wait_for_finalization=wait_for_finalization,
         period=period,
+        raise_error=raise_error,
     )