[v10] Unify extrinsic return values by introducing an ExtrinsicResponse class

.github/workflows/_run-e2e-single.yaml

@@ -41,8 +41,11 @@ jobs:
           path: |
             ~/.cache/uv
             .venv
-          key: uv-${{ runner.os }}-py${{ matrix.python-version }}-${{ hashFiles('pyproject.toml') }}
-          restore-keys: uv-${{ runner.os }}-py${{ matrix.python-version }}-
+          key: |
+            uv-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ hashFiles('pyproject.toml') }}
+          restore-keys: |
+            uv-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ hashFiles('pyproject.toml') }}
+            uv-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-
 
       - name: Install dependencies
         run: uv sync --extra dev --dev

bittensor/core/extrinsics/asyncex/children.py

@@ -1,5 +1,8 @@
 from typing import TYPE_CHECKING, Optional
-from bittensor.utils import float_to_u64, unlock_key
+
+from bittensor.core.types import ExtrinsicResponse
+from bittensor.utils import float_to_u64, unlock_key, get_function_name
+from bittensor.utils.btlogging import logging
 
 if TYPE_CHECKING:
     from bittensor_wallet import Wallet
@@ -16,7 +19,7 @@ async def set_children_extrinsic(
     raise_error: bool = False,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
-) -> tuple[bool, str]:
+) -> ExtrinsicResponse:
     """
     Allows a coldkey to set children-keys.
 
@@ -34,9 +37,7 @@ async def set_children_extrinsic(
         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.
+        ExtrinsicResponse: The result object of the extrinsic execution.
 
     Raises:
         DuplicateChild: There are duplicates in the list of children.
@@ -54,7 +55,10 @@ async def set_children_extrinsic(
     unlock = unlock_key(wallet, raise_error=raise_error)
 
     if not unlock.success:
-        return False, unlock.message
+        logging.error(unlock.message)
+        return ExtrinsicResponse(
+            False, unlock.message, extrinsic_function=get_function_name()
+        )
 
     async with subtensor.substrate as substrate:
         call = await substrate.compose_call(
@@ -73,22 +77,23 @@ async def set_children_extrinsic(
             },
         )
 
-        success, message = await subtensor.sign_and_send_extrinsic(
+        response = 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,
+            calling_function=get_function_name(),
         )
 
         if not wait_for_finalization and not wait_for_inclusion:
-            return True, message
+            return response
 
-        if success:
-            return True, "Success with `set_children_extrinsic` response."
+        if response.success:
+            return response
 
-        return True, message
+        return response
 
 
 async def root_set_pending_childkey_cooldown_extrinsic(
@@ -99,7 +104,7 @@ async def root_set_pending_childkey_cooldown_extrinsic(
     raise_error: bool = False,
     wait_for_inclusion: bool = True,
     wait_for_finalization: bool = True,
-) -> tuple[bool, str]:
+) -> ExtrinsicResponse:
     """
     Allows a root coldkey to set children-keys.
 
@@ -115,14 +120,13 @@ async def root_set_pending_childkey_cooldown_extrinsic(
         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.
+        ExtrinsicResponse: The result object of the extrinsic execution.
     """
-    unlock = unlock_key(wallet)
-
-    if not unlock.success:
-        return False, unlock.message
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return ExtrinsicResponse(
+            False, unlock.message, extrinsic_function=get_function_name()
+        )
 
     async with subtensor.substrate as substrate:
         call = await substrate.compose_call(
@@ -137,22 +141,20 @@ async def root_set_pending_childkey_cooldown_extrinsic(
             call_params={"call": call},
         )
 
-        success, message = await subtensor.sign_and_send_extrinsic(
+        response = 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,
+            calling_function=get_function_name(),
         )
 
         if not wait_for_finalization and not wait_for_inclusion:
-            return True, message
+            return response
 
-        if success:
-            return (
-                True,
-                "Success with `root_set_pending_childkey_cooldown_extrinsic` response.",
-            )
+        if response.success:
+            return response
 
-        return True, message
+        return response

bittensor/core/extrinsics/asyncex/commit_reveal.py

@@ -7,6 +7,8 @@
 from numpy.typing import NDArray
 
 from bittensor.core.settings import version_as_int
+from bittensor.core.types import ExtrinsicResponse
+from bittensor.utils import get_function_name, unlock_key
 from bittensor.utils.btlogging import logging
 from bittensor.utils.weight_utils import convert_and_normalize_weights_and_uids
 
@@ -29,7 +31,7 @@ async def commit_reveal_extrinsic(
     raise_error: bool = False,
     wait_for_inclusion: bool = False,
     wait_for_finalization: bool = False,
-) -> tuple[bool, str]:
+) -> ExtrinsicResponse:
     """
     Commits and reveals weights for a given subtensor and wallet with provided uids and weights.
 
@@ -50,67 +52,68 @@ async def commit_reveal_extrinsic(
         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.
+        ExtrinsicResponse: The result object of the extrinsic execution.
     """
-    try:
-        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(
-            netuid, block_hash=current_block["header"]["hash"]
+    if not (unlock := unlock_key(wallet, unlock_type="hotkey")).success:
+        logging.error(unlock.message)
+        return ExtrinsicResponse(
+            False, unlock.message, extrinsic_function=get_function_name()
         )
-        tempo = subnet_hyperparameters.tempo
-        subnet_reveal_period_epochs = subnet_hyperparameters.commit_reveal_period
 
-        # Encrypt `commit_hash` with t-lock and `get reveal_round`
-        commit_for_reveal, reveal_round = get_encrypted_commit(
-            uids=uids,
-            weights=weights,
-            version_key=version_key,
-            tempo=tempo,
-            current_block=current_block["header"]["number"],
-            netuid=netuid,
-            subnet_reveal_period_epochs=subnet_reveal_period_epochs,
-            block_time=block_time,
-            hotkey=wallet.hotkey.public_key,
-        )
+    uids, weights = convert_and_normalize_weights_and_uids(uids, weights)
 
-        logging.info(
-            f"Committing weights hash [blue]{commit_for_reveal.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
-            f"reveal round [blue]{reveal_round}[/blue]..."
-        )
+    current_block = await subtensor.substrate.get_block(None)
+    subnet_hyperparameters = await subtensor.get_subnet_hyperparameters(
+        netuid, block_hash=current_block["header"]["hash"]
+    )
+    tempo = subnet_hyperparameters.tempo
+    subnet_reveal_period_epochs = subnet_hyperparameters.commit_reveal_period
 
-        call = await subtensor.substrate.compose_call(
-            call_module="SubtensorModule",
-            call_function="commit_timelocked_weights",
-            call_params={
-                "netuid": netuid,
-                "commit": commit_for_reveal,
-                "reveal_round": reveal_round,
-                "commit_reveal_version": commit_reveal_version,
-            },
-        )
-        success, message = await subtensor.sign_and_send_extrinsic(
-            call=call,
-            wallet=wallet,
-            wait_for_inclusion=wait_for_inclusion,
-            wait_for_finalization=wait_for_finalization,
-            sign_with="hotkey",
-            period=period,
-            raise_error=raise_error,
-        )
+    # Encrypt `commit_hash` with t-lock and `get reveal_round`
+    commit_for_reveal, reveal_round = get_encrypted_commit(
+        uids=uids,
+        weights=weights,
+        version_key=version_key,
+        tempo=tempo,
+        current_block=current_block["header"]["number"],
+        netuid=netuid,
+        subnet_reveal_period_epochs=subnet_reveal_period_epochs,
+        block_time=block_time,
+        hotkey=wallet.hotkey.public_key,
+    )
+
+    logging.info(
+        f"Committing weights hash [blue]{commit_for_reveal.hex()}[/blue] for subnet #[blue]{netuid}[/blue] with "
+        f"reveal round [blue]{reveal_round}[/blue]..."
+    )
 
-        if not success:
-            logging.error(message)
-            return False, message
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="commit_timelocked_weights",
+        call_params={
+            "netuid": netuid,
+            "commit": commit_for_reveal,
+            "reveal_round": reveal_round,
+            "commit_reveal_version": commit_reveal_version,
+        },
+    )
+    response = await subtensor.sign_and_send_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+        sign_with="hotkey",
+        period=period,
+        raise_error=raise_error,
+        calling_function=get_function_name(),
+    )
 
+    if response.success:
         logging.success(
             f"[green]Finalized![/green] Weights committed with reveal round [blue]{reveal_round}[/blue]."
         )
-        return True, f"reveal_round:{reveal_round}"
+        response.data = {"reveal_round": reveal_round}
+        return response
 
-    except Exception as e:
-        logging.error(f":cross_mark: [red]Failed. Error:[/red] {e}")
-        return False, str(e)
+    logging.error(response.message)
+    return response