Release/9.0.0rc6

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

@@ -90,7 +90,7 @@ jobs:
 
       - name: Setup subtensor repo
         working-directory: ${{ github.workspace }}/subtensor
-        run: git checkout main
+        run: git checkout devnet-ready
 
       - name: Run tests
         run: |

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 9.0.0rc6 /2025-02-11
+* Using one determine_chain_endpoint_and_network by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2661
+* Tests: separate templates fixture by @zyzniewski-reef  in https://github.com/opentensor/bittensor/pull/2660
+* add name and symbol fields to metagraph by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2658
+* Metagraph Improvements by @thewhaleking in https://github.com/opentensor/bittensor/pull/2659
+* feat/roman/add-subnet-identity-with-subnet-creation by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2662
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v9.0.0rc5...v9.0.0rc6
+
 ## 9.0.0rc5 /2025-02-07
 * Fix InfoBase + dataclasses @roman-opentensor in https://github.com/opentensor/bittensor/pull/2649
 
@@ -38,6 +47,25 @@
 
 **Full Changelog**: https://github.com/opentensor/bittensor/compare/v8.5.1...v9.0.0rc1
 
+## 8.5.2 /2025-01-17
+
+## What's Changed
+* Feat/use tx pool for set weights by @camfairchild in https://github.com/opentensor/bittensor/pull/2534
+* fix get_delegates result decoding by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2551
+* [SDK] Handle server connection limit  by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2553
+* Backmerge master to staging post 851 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2557
+* [SDK] Improve InvalidStatus handler by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2558
+* [SDK] Add async version of commit reveal v3 by @roman-opentensor in https://github.com/opentensor/bittensor/pull/2560
+* Use apt-get instead of apt for scripts by @camfairchild in https://github.com/opentensor/bittensor/pull/2571
+* fix _do_stake incorrect arguments error in staking.py by @Assh-codes in https://github.com/opentensor/bittensor/pull/2574
+* Updates tests for btwallet 3.0.0 by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2540
+* Bumps cr3 FFI by @ibraheem-opentensor in https://github.com/opentensor/bittensor/pull/2583
+
+## New Contributors
+* @Assh-codes made their first contribution in https://github.com/opentensor/bittensor/pull/2574
+
+**Full Changelog**: https://github.com/opentensor/bittensor/compare/v8.5.1...v8.5.2
+
 ## 8.5.1 /2024-12-16
 
 ## What's Changed

VERSION

@@ -1 +1 @@
-9.0.0rc5
+9.0.0rc6

bittensor/core/async_subtensor.py

@@ -21,6 +21,7 @@
     NeuronInfo,
     ProposalVoteData,
     SubnetHyperparameters,
+    SubnetIdentity,
     SubnetInfo,
     WeightCommitInfo,
     decode_account_id,
@@ -34,6 +35,7 @@
     burned_register_extrinsic,
     register_extrinsic,
     register_subnet_extrinsic,
+    set_subnet_identity_extrinsic,
 )
 from bittensor.core.extrinsics.asyncex.move_stake import (
     transfer_stake_extrinsic,
@@ -2581,8 +2583,8 @@ async def wait_for_block(self, block: Optional[int] = None):
             bool: True if the target block was reached, False if timeout occurred.
 
         Example:
-            >>> await subtensor.wait_for_block() # Waits for next block
-            >>> await subtensor.wait_for_block(block=1234) # Waits for specific block
+            await subtensor.wait_for_block() # Waits for next block
+            await subtensor.wait_for_block(block=1234) # Waits for specific block
         """
 
         async def handler(block_data: dict):
@@ -3188,6 +3190,44 @@ async def root_set_weights(
             wait_for_inclusion=wait_for_inclusion,
         )
 
+    async def set_subnet_identity(
+        self,
+        wallet: "Wallet",
+        netuid: int,
+        subnet_identity: SubnetIdentity,
+        wait_for_inclusion: bool = False,
+        wait_for_finalization: bool = True,
+    ) -> tuple[bool, str]:
+        """
+        Sets the identity of a subnet for a specific wallet and network.
+
+        Arguments:
+            wallet (Wallet): The wallet instance that will authorize the transaction.
+            netuid (int): The unique ID of the network on which the operation takes place.
+            subnet_identity (SubnetIdentity): The identity data of the subnet including attributes like name, GitHub
+                repository, contact, URL, discord, description, and any additional metadata.
+            wait_for_inclusion (bool): Indicates if the function should wait for the transaction to be included in the block.
+            wait_for_finalization (bool): Indicates if the function should wait for the transaction to reach finalization.
+
+        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.
+        """
+        return await set_subnet_identity_extrinsic(
+            subtensor=self,
+            wallet=wallet,
+            netuid=netuid,
+            subnet_name=subnet_identity.subnet_name,
+            github_repo=subnet_identity.github_repo,
+            subnet_contact=subnet_identity.subnet_contact,
+            subnet_url=subnet_identity.subnet_url,
+            discord=subnet_identity.discord,
+            description=subnet_identity.description,
+            additional=subnet_identity.additional,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
     async def set_weights(
         self,
         wallet: "Wallet",

bittensor/core/dendrite.py

@@ -163,14 +163,18 @@ async def session(self) -> aiohttp.ClientSession:
             self._session = aiohttp.ClientSession()
         return self._session
 
-    def close_session(self):
+    def close_session(self, using_new_loop: bool = False):
         """
         Closes the internal `aiohttp <https://github.com/aio-libs/aiohttp>`_ client session synchronously.
 
         This method ensures the proper closure and cleanup of the aiohttp client session, releasing any
         resources like open connections and internal buffers. It is crucial for preventing resource leakage
         and should be called when the dendrite instance is no longer in use, especially in synchronous contexts.
 
+        Arguments:
+            using_new_loop: A flag to determine whether this has been called with a new event loop rather than
+                the default. This will indicate whether to close this event loop at the end of this call.
+
         Note:
             This method utilizes asyncio's event loop to close the session asynchronously from a synchronous context.
             It is advisable to use this method only when asynchronous context management is not feasible.
@@ -188,6 +192,8 @@ def close_session(self):
         if self._session:
             loop = asyncio.get_event_loop()
             loop.run_until_complete(self._session.close())
+            if using_new_loop:
+                loop.close()
             self._session = None
 
     async def aclose_session(self):
@@ -374,16 +380,20 @@ def query(
                 category=DeprecationWarning,
             )
         result = None
+        use_new_loop = False
         try:
             loop = asyncio.get_event_loop()
             result = loop.run_until_complete(self.forward(*args, **kwargs))
-        except Exception:
+        except Exception as e:
+            logging.debug(
+                f"Exception encountered while running Dendrite.query initially: {e}"
+            )
             new_loop = asyncio.new_event_loop()
             asyncio.set_event_loop(new_loop)
             result = new_loop.run_until_complete(self.forward(*args, **kwargs))
-            new_loop.close()
+            use_new_loop = True
         finally:
-            self.close_session()
+            self.close_session(using_new_loop=use_new_loop)
             return result  # type: ignore
 
     async def forward(

bittensor/core/extrinsics/asyncex/move_stake.py

@@ -290,14 +290,6 @@ async def move_stake_extrinsic(
         bool: True if the move was successful, False otherwise.
     """
     amount.set_unit(netuid=origin_netuid)
-    # Verify ownership of origin hotkey
-    origin_owner = await subtensor.get_hotkey_owner(origin_hotkey)
-    if origin_owner != wallet.coldkeypub.ss58_address:
-        logging.error(
-            f":cross_mark: [red]Failed[/red]: Origin hotkey: {origin_hotkey} does not belong to the coldkey owner: "
-            f"{wallet.coldkeypub.ss58_address}"
-        )
-        return False
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = await _get_stake_in_origin_and_dest(

bittensor/core/extrinsics/asyncex/registration.py

@@ -430,14 +430,92 @@ async def register_subnet_extrinsic(
     if not wait_for_finalization and not wait_for_inclusion:
         return True
 
-    await response.process_events()
     if not await response.is_success:
         logging.error(
-            f"Failed to register subnet: {format_error_message(await response.error_message, subtensor.substrate)}"
+            f"Failed to register subnet: {format_error_message(await response.error_message)}"
         )
         return False
 
     logging.success(
         ":white_heavy_check_mark: [green]Successfully registered subnet[/green]"
     )
     return True
+
+
+async def set_subnet_identity_extrinsic(
+    subtensor: "AsyncSubtensor",
+    wallet: "Wallet",
+    netuid: int,
+    subnet_name: str,
+    github_repo: str,
+    subnet_contact: str,
+    subnet_url: str,
+    discord: str,
+    description: str,
+    additional: str,
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = True,
+) -> tuple[bool, str]:
+    """
+    Set the identity information for a given subnet.
+
+    Arguments:
+        subtensor (AsyncSubtensor): An instance of the Subtensor class to interact with the blockchain.
+        wallet (Wallet): A wallet instance used to sign and submit the extrinsic.
+        netuid (int): The unique ID for the subnet.
+        subnet_name (str): The name of the subnet to assign the identity information.
+        github_repo (str): URL of the GitHub repository related to the subnet.
+        subnet_contact (str): Subnet's contact information, e.g., email or contact link.
+        subnet_url (str): The URL of the subnet's primary web portal.
+        discord (str): Discord server or contact for the subnet.
+        description (str): A textual description of the subnet.
+        additional (str): Any additional metadata or information related to the subnet.
+        wait_for_inclusion (bool): Whether to wait for the extrinsic inclusion in a block (default: False).
+        wait_for_finalization (bool): Whether to wait for the extrinsic finalization in a block (default: True).
+
+    Returns:
+        tuple[bool, str]: A tuple where the first element indicates success or failure (True/False), and the second
+            element contains a descriptive message.
+    """
+
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    call = await subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="set_subnet_identity",
+        call_params={
+            "hotkey": wallet.hotkey.ss58_address,
+            "netuid": netuid,
+            "subnet_name": subnet_name,
+            "github_repo": github_repo,
+            "subnet_contact": subnet_contact,
+            "subnet_url": subnet_url,
+            "discord": discord,
+            "description": description,
+            "additional": additional,
+        },
+    )
+
+    response = await subtensor.substrate.submit_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    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:
+        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}"

bittensor/core/extrinsics/move_stake.py

@@ -289,13 +289,6 @@ def move_stake_extrinsic(
     """
 
     amount.set_unit(netuid=origin_netuid)
-    # Verify ownership of origin hotkey
-    origin_owner = subtensor.get_hotkey_owner(origin_hotkey)
-    if origin_owner != wallet.coldkeypub.ss58_address:
-        logging.error(
-            f":cross_mark: [red]Failed[/red]: Origin hotkey: {origin_hotkey} does not belong to the coldkey owner: {wallet.coldkeypub.ss58_address}"
-        )
-        return False
 
     # Check sufficient stake
     stake_in_origin, stake_in_destination = _get_stake_in_origin_and_dest(

bittensor/core/extrinsics/registration.py

@@ -424,3 +424,81 @@ def register_extrinsic(
             # Failed to register after max attempts.
             logging.error("[red]No more attempts.[/red]")
             return False
+
+
+def set_subnet_identity_extrinsic(
+    subtensor: "Subtensor",
+    wallet: "Wallet",
+    netuid: int,
+    subnet_name: str,
+    github_repo: str,
+    subnet_contact: str,
+    subnet_url: str,
+    discord: str,
+    description: str,
+    additional: str,
+    wait_for_inclusion: bool = False,
+    wait_for_finalization: bool = True,
+) -> tuple[bool, str]:
+    """
+    Set the identity information for a given subnet.
+
+    Arguments:
+        subtensor (Subtensor): An instance of the Subtensor class to interact with the blockchain.
+        wallet (Wallet): A wallet instance used to sign and submit the extrinsic.
+        netuid (int): The unique ID for the subnet.
+        subnet_name (str): The name of the subnet to assign the identity information.
+        github_repo (str): URL of the GitHub repository related to the subnet.
+        subnet_contact (str): Subnet's contact information, e.g., email or contact link.
+        subnet_url (str): The URL of the subnet's primary web portal.
+        discord (str): Discord server or contact for the subnet.
+        description (str): A textual description of the subnet.
+        additional (str): Any additional metadata or information related to the subnet.
+        wait_for_inclusion (bool): Whether to wait for the extrinsic inclusion in a block (default: False).
+        wait_for_finalization (bool): Whether to wait for the extrinsic finalization in a block (default: True).
+
+    Returns:
+        tuple[bool, str]: A tuple where the first element indicates success or failure (True/False), and the second
+            element contains a descriptive message.
+    """
+
+    if not (unlock := unlock_key(wallet)).success:
+        logging.error(unlock.message)
+        return False, unlock.message
+
+    call = subtensor.substrate.compose_call(
+        call_module="SubtensorModule",
+        call_function="set_subnet_identity",
+        call_params={
+            "hotkey": wallet.hotkey.ss58_address,
+            "netuid": netuid,
+            "subnet_name": subnet_name,
+            "github_repo": github_repo,
+            "subnet_contact": subnet_contact,
+            "subnet_url": subnet_url,
+            "discord": discord,
+            "description": description,
+            "additional": additional,
+        },
+    )
+
+    success, message = subtensor.sign_and_send_extrinsic(
+        call=call,
+        wallet=wallet,
+        wait_for_inclusion=wait_for_inclusion,
+        wait_for_finalization=wait_for_finalization,
+    )
+
+    if not wait_for_finalization and not wait_for_inclusion:
+        return True, f"Identities for subnet {netuid} are sent to the chain."
+
+    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:
+        logging.error(
+            f":cross_mark: Failed to set identity for subnet [blue]{netuid}[/blue]: {message}"
+        )
+        return False, f"Failed to set identity for subnet {netuid}: {message}"