Merge branch 'staging' into master

Author: thewhaleking

CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 9.3.1a1 /2025-04-14
+
+## What's Changed
+* Release/9.3.0 by @ibraheem-abe in https://github.com/opentensor/bittensor/pull/2805
+* Fix for flaky behavior of `test_incentive`, `test_commit_weights` and `test_set_weights`  by @basfroman in https://github.com/opentensor/bittensor/pull/2795
+* Add `get_next_epoch_start_block` method to Async/Subtensor by @basfroman in https://github.com/opentensor/bittensor/pull/2808
+* Adds compatibility for torch 2.6.0+ by @thewhaleking in https://github.com/opentensor/bittensor/pull/2811
+* f Update CONTRIBUTING.md by @Hack666r in https://github.com/opentensor/bittensor/pull/2813
+* docs: replaced discord link with documentation by @sashaphmn in https://github.com/opentensor/bittensor/pull/2809
+* sometimes it's still flaky because the chain returns data with time offset by @basfroman in https://github.com/opentensor/bittensor/pull/2816
+* Remove requirements directory by @thewhaleking in https://github.com/opentensor/bittensor/pull/2812
+* version in one place by @thewhaleking in https://github.com/opentensor/bittensor/pull/2806
+* Update CONTRIBUTING hyperlinks by @thewhaleking in https://github.com/opentensor/bittensor/pull/2820
+
+## New Contributors
+* @Hack666r made their first contribution in https://github.com/opentensor/bittensor/pull/2813
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.3.0...v9.3.1a1
+
 ## 9.3.0 /2025-04-09
 
 ## What's Changed

Makefile

@@ -21,6 +21,3 @@ install:
 
 install-dev:
 	python3 -m pip install '.[dev]'
-
-install-cubit:
-	python3 -m pip install '.[cubit]'

bittensor/core/async_subtensor.py

@@ -57,6 +57,7 @@
     publish_metadata,
     get_metadata,
 )
+from bittensor.core.extrinsics.asyncex.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.asyncex.serving import serve_axon_extrinsic
 from bittensor.core.extrinsics.asyncex.staking import (
     add_stake_extrinsic,
@@ -3181,7 +3182,7 @@ async def sign_and_send_extrinsic(
                 return True, ""
 
             if raise_error:
-                raise ChainError.from_error(response.error_message)
+                raise ChainError.from_error(await response.error_message)
 
             return False, format_error_message(await response.error_message)
 
@@ -3986,6 +3987,36 @@ async def serve_axon(
             certificate=certificate,
         )
 
+    async def start_call(
+        self,
+        wallet: "Wallet",
+        netuid: int,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+    ) -> tuple[bool, str]:
+        """
+        Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+        new subnet's emission mechanism).
+
+        Args:
+            wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+            netuid (int): The UID of the target subnet for which the call is being initiated.
+            wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+            wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+        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.
+        """
+        return await start_call_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
     async def swap_stake(
         self,
         wallet: "Wallet",

bittensor/core/chain_data/metagraph_info.py

@@ -25,7 +25,7 @@ def _chr_str(codes: tuple[int]) -> str:
 def process_nested(data: Union[tuple, dict], chr_transform):
     """Processes nested data structures by applying a transformation function to their elements."""
     if isinstance(data, (list, tuple)):
-        if len(data) > 0 and isinstance(data[0], dict):
+        if len(data) > 0:
             return [
                 {k: chr_transform(v) for k, v in item.items()}
                 if item is not None

bittensor/core/extrinsics/asyncex/registration.py

@@ -498,7 +498,7 @@ async def set_subnet_identity_extrinsic(
         },
     )
 
-    response = await subtensor.substrate.submit_extrinsic(
+    success, error_message = await subtensor.sign_and_send_extrinsic(
         call=call,
         wallet=wallet,
         wait_for_inclusion=wait_for_inclusion,
@@ -508,14 +508,13 @@ async def set_subnet_identity_extrinsic(
     if not wait_for_finalization and not wait_for_inclusion:
         return True, f"Identities for subnet {netuid} are sent to the chain."
 
-    if await response.is_success:
+    if success:
         logging.success(
             f":white_heavy_check_mark: [green]Identities for subnet[/green] [blue]{netuid}[/blue] [green]are set.[/green]"
         )
         return True, f"Identities for subnet {netuid} are set."
-    else:
-        error_message = await response.error_message
-        logging.error(
-            f":cross_mark: Failed to set identity for subnet [blue]{netuid}[/blue]: {error_message}"
-        )
-        return False, f"Failed to set identity for subnet {netuid}: {error_message}"
+
+    logging.error(
+        f":cross_mark: Failed to set identity for subnet [blue]{netuid}[/blue]: {error_message}"
+    )
+    return False, f"Failed to set identity for subnet {netuid}: {error_message}"

bittensor/core/extrinsics/asyncex/start_call.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING
+
+from bittensor.utils import unlock_key
+from bittensor.utils.btlogging import logging
+
+if TYPE_CHECKING:
+    from bittensor_wallet import Wallet
+    from bittensor.core.async_subtensor import AsyncSubtensor
+
+
+async def start_call_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+    """
+    Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+    new subnet's emission mechanism).
+
+    Args:
+        subtensor (Subtensor): The Subtensor client instance used for blockchain interaction.
+        wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+        netuid (int): The UID of the target subnet for which the call is being initiated.
+        wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+        wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+    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.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    async with subtensor.substrate as substrate:
+        start_call = await substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="start_call",
+            call_params={"netuid": netuid},
+        )
+        signed_ext = await substrate.create_signed_extrinsic(
+            call=start_call,
+            keypair=wallet.coldkey,
+        )
+
+        response = await substrate.submit_extrinsic(
+            extrinsic=signed_ext,
+            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 await response.is_success:
+            return True, "Success with `start_call` response."
+
+        return False, await response.error_message

bittensor/core/extrinsics/start_call.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING
+
+from bittensor.utils import unlock_key
+from bittensor.utils.btlogging import logging
+
+if TYPE_CHECKING:
+    from bittensor_wallet import Wallet
+    from bittensor.core.subtensor import Subtensor
+
+
+def start_call_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    netuid: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str]:
+    """
+    Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+    new subnet's emission mechanism).
+
+    Args:
+        subtensor (Subtensor): The Subtensor client instance used for blockchain interaction.
+        wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+        netuid (int): The UID of the target subnet for which the call is being initiated.
+        wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+        wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+    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.
+    """
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    with subtensor.substrate as substrate:
+        start_call = substrate.compose_call(
+            call_module="SubtensorModule",
+            call_function="start_call",
+            call_params={"netuid": netuid},
+        )
+
+        signed_ext = substrate.create_signed_extrinsic(
+            call=start_call,
+            keypair=wallet.coldkey,
+        )
+
+        response = substrate.submit_extrinsic(
+            extrinsic=signed_ext,
+            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 response.is_success:
+            return True, "Success with `start_call` response."
+
+        return False, response.error_message

bittensor/core/subtensor.py

@@ -60,6 +60,7 @@
     get_metadata,
     serve_axon_extrinsic,
 )
+from bittensor.core.extrinsics.start_call import start_call_extrinsic
 from bittensor.core.extrinsics.set_weights import set_weights_extrinsic
 from bittensor.core.extrinsics.staking import (
     add_stake_extrinsic,
@@ -3252,6 +3253,36 @@ def serve_axon(
             certificate=certificate,
         )
 
+    def start_call(
+        self,
+        wallet: "Wallet",
+        netuid: int,
+        wait_for_inclusion: bool = True,
+        wait_for_finalization: bool = False,
+    ) -> tuple[bool, str]:
+        """
+        Submits a start_call extrinsic to the blockchain, to trigger the start call process for a subnet (used to start a
+        new subnet's emission mechanism).
+
+        Args:
+            wallet (Wallet): The wallet used to sign the extrinsic (must be unlocked).
+            netuid (int): The UID of the target subnet for which the call is being initiated.
+            wait_for_inclusion (bool, optional): Whether to wait for the extrinsic to be included in a block. Defaults to True.
+            wait_for_finalization (bool, optional): Whether to wait for finalization of the extrinsic. Defaults to False.
+
+        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.
+        """
+        return start_call_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
     def swap_stake(
         self,
         wallet: "Wallet",