bittensor-cli 9.7.1__py3-none-any.whl → 9.8.1__py3-none-any.whl

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -531,6 +531,33 @@ class SubtensorInterface:
                 res.append(record[0])
         return res
 
+    async def is_subnet_active(
+        self,
+        netuid: int,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> bool:
+        """Verify if subnet with provided netuid is active.
+
+        Args:
+            netuid (int): The unique identifier of the subnet.
+            block_hash (Optional[str]): The blockchain block_hash representation of block id.
+            reuse_block (bool): Whether to reuse the last-used block hash.
+
+        Returns:
+            True if subnet is active, False otherwise.
+
+        This means whether the `start_call` was initiated or not.
+        """
+        query = await self.substrate.query(
+            module="SubtensorModule",
+            storage_function="FirstEmissionBlockNumber",
+            block_hash=block_hash,
+            reuse_block_hash=reuse_block,
+            params=[netuid],
+        )
+        return True if query and query.value > 0 else False
+
     async def subnet_exists(
         self, netuid: int, block_hash: Optional[str] = None, reuse_block: bool = False
     ) -> bool:
@@ -1128,22 +1155,13 @@ class SubtensorInterface:
         Understanding the hyperparameters is crucial for comprehending how subnets are configured and
         managed, and how they interact with the network's consensus and incentive mechanisms.
         """
-        main_result, yuma3_result, sigmoid_steepness = await asyncio.gather(
-            self.query_runtime_api(
-                runtime_api="SubnetInfoRuntimeApi",
-                method="get_subnet_hyperparams",
-                params=[netuid],
-                block_hash=block_hash,
-            ),
-            self.query("SubtensorModule", "Yuma3On", [netuid]),
-            self.query("SubtensorModule", "AlphaSigmoidSteepness", [netuid]),
+        result = await self.query_runtime_api(
+            runtime_api="SubnetInfoRuntimeApi",
+            method="get_subnet_hyperparams_v2",
+            params=[netuid],
+            block_hash=block_hash,
         )
-        result = {
-            **main_result,
-            **{"yuma3_enabled": yuma3_result},
-            **{"alpha_sigmoid_steepness": sigmoid_steepness},
-        }
-        if not main_result:
+        if not result:
             return []
 
         return SubnetHyperparameters.from_any(result)
@@ -1405,23 +1423,40 @@ class SubtensorInterface:
         return stake_info_map if stake_info_map else None
 
     async def all_subnets(self, block_hash: Optional[str] = None) -> list[DynamicInfo]:
-        result = await self.query_runtime_api(
-            "SubnetInfoRuntimeApi",
-            "get_all_dynamic_info",
-            block_hash=block_hash,
+        result, prices = await asyncio.gather(
+            self.query_runtime_api(
+                "SubnetInfoRuntimeApi",
+                "get_all_dynamic_info",
+                block_hash=block_hash,
+            ),
+            self.get_subnet_prices(block_hash=block_hash, page_size=129),
         )
-        return DynamicInfo.list_from_any(result)
+        sns: list[DynamicInfo] = DynamicInfo.list_from_any(result)
+        for sn in sns:
+            if sn.netuid == 0:
+                sn.price = Balance.from_tao(1.0)
+            else:
+                try:
+                    sn.price = prices[sn.netuid]
+                except KeyError:
+                    sn.price = sn.tao_in / sn.alpha_in
+        return sns
 
     async def subnet(
         self, netuid: int, block_hash: Optional[str] = None
     ) -> "DynamicInfo":
-        result = await self.query_runtime_api(
-            "SubnetInfoRuntimeApi",
-            "get_dynamic_info",
-            params=[netuid],
-            block_hash=block_hash,
+        result, price = await asyncio.gather(
+            self.query_runtime_api(
+                "SubnetInfoRuntimeApi",
+                "get_dynamic_info",
+                params=[netuid],
+                block_hash=block_hash,
+            ),
+            self.get_subnet_price(netuid=netuid, block_hash=block_hash),
         )
-        return DynamicInfo.from_any(result)
+        subnet_ = DynamicInfo.from_any(result)
+        subnet_.price = price
+        return subnet_
 
     async def get_owned_hotkeys(
         self,
@@ -1563,3 +1598,53 @@ class SubtensorInterface:
         )
 
         return result
+
+    async def get_subnet_price(
+        self,
+        netuid: int = None,
+        block_hash: Optional[str] = None,
+    ) -> Balance:
+        """
+        Gets the current Alpha price in TAO for a specific subnet.
+
+        :param netuid: The unique identifier of the subnet.
+        :param block_hash: The hash of the block to retrieve the price from.
+
+        :return: The current Alpha price in TAO units for the specified subnet.
+        """
+        current_sqrt_price = await self.query(
+            module="Swap",
+            storage_function="AlphaSqrtPrice",
+            params=[netuid],
+            block_hash=block_hash,
+        )
+
+        current_sqrt_price = fixed_to_float(current_sqrt_price)
+        current_price = current_sqrt_price * current_sqrt_price
+        return Balance.from_rao(int(current_price * 1e9))
+
+    async def get_subnet_prices(
+        self, block_hash: Optional[str] = None, page_size: int = 100
+    ) -> dict[int, Balance]:
+        """
+        Gets the current Alpha prices in TAO for all subnets.
+
+        :param block_hash: The hash of the block to retrieve prices from.
+        :param page_size: The page size for batch queries (default: 100).
+
+        :return: A dictionary mapping netuid to the current Alpha price in TAO units.
+        """
+        query = await self.substrate.query_map(
+            module="Swap",
+            storage_function="AlphaSqrtPrice",
+            page_size=page_size,
+            block_hash=block_hash,
+        )
+
+        map_ = {}
+        async for netuid_, current_sqrt_price in query:
+            current_sqrt_price_ = fixed_to_float(current_sqrt_price.value)
+            current_price = current_sqrt_price_**2
+            map_[netuid_] = Balance.from_rao(int(current_price * 1e9))
+
+        return map_

bittensor_cli/src/bittensor/utils.py

@@ -1177,6 +1177,7 @@ def prompt_for_subnet_identity(
     subnet_url: Optional[str],
     discord: Optional[str],
     description: Optional[str],
+    logo_url: Optional[str],
     additional: Optional[str],
 ):
     """
@@ -1237,6 +1238,13 @@ def prompt_for_subnet_identity(
             lambda x: x and len(x.encode("utf-8")) > 1024,
             "[red]Error:[/red] Description must be <= 1024 bytes.",
         ),
+        (
+            "logo_url",
+            "[blue]Logo URL [dim](optional)[/blue]",
+            logo_url,
+            lambda x: x and len(x.encode("utf-8")) > 1024,
+            "[red]Error:[/red] Logo URL must be <= 1024 bytes.",
+        ),
         (
             "additional",
             "[blue]Additional information [dim](optional)[/blue]",
@@ -1371,6 +1379,7 @@ def unlock_key(
         err_msg = f"The password used to decrypt your {unlock_type.capitalize()}key Keyfile is invalid."
         if print_out:
             err_console.print(f":cross_mark: [red]{err_msg}[/red]")
+            return unlock_key(wallet, unlock_type, print_out)
         return UnlockStatus(False, err_msg)
     except KeyFileError:
         err_msg = f"{unlock_type.capitalize()}key Keyfile is corrupt, non-writable, or non-readable, or non-existent."