Merge branch 'SDKv10' into docstrings-updates-for-v10

Author: basfroman

bittensor/core/async_subtensor.py

@@ -3915,7 +3915,7 @@ async def get_stake_info_for_coldkey(
         block: Optional[int] = None,
         block_hash: Optional[str] = None,
         reuse_block: bool = False,
-    ) -> Optional[list["StakeInfo"]]:
+    ) -> list["StakeInfo"]:
         """
         Retrieves the stake information for a given coldkey.
 
@@ -3926,7 +3926,7 @@ async def get_stake_info_for_coldkey(
             reuse_block: Whether to reuse the last-used block hash.
 
         Returns:
-            An optional list of StakeInfo objects, or ``None`` if no stake information is found.
+            List of StakeInfo objects.
         """
         result = await self.query_runtime_api(
             runtime_api="StakeInfoRuntimeApi",
@@ -3943,6 +3943,42 @@ async def get_stake_info_for_coldkey(
         stakes: list[StakeInfo] = StakeInfo.list_from_dicts(result)
         return [stake for stake in stakes if stake.stake > 0]
 
+    async def get_stake_info_for_coldkeys(
+        self,
+        coldkey_ss58s: list[str],
+        block: Optional[int] = None,
+        block_hash: Optional[str] = None,
+        reuse_block: bool = False,
+    ) -> dict[str, list["StakeInfo"]]:
+        """
+        Retrieves the stake information for multiple coldkeys.
+
+        Parameters:
+            coldkey_ss58s: A list of SS58 addresses of the coldkeys to query.
+            block: The block number at which to query the stake information.
+            block_hash: The hash of the blockchain block number for the query.
+            reuse_block: Whether to reuse the last-used block hash.
+
+        Returns:
+            The dictionary mapping coldkey addresses to a list of StakeInfo objects.
+        """
+        query = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_info_for_coldkeys",
+            params=[coldkey_ss58s],
+            block=block,
+            block_hash=block_hash,
+            reuse_block=reuse_block,
+        )
+
+        if query is None:
+            return {}
+
+        return {
+            decode_account_id(ck): StakeInfo.list_from_dicts(st_info)
+            for ck, st_info in query
+        }
+
     async def get_stake_for_hotkey(
         self,
         hotkey_ss58: str,
@@ -5619,7 +5655,7 @@ async def sign_and_send_extrinsic(
                 wait_for_inclusion=wait_for_inclusion,
                 wait_for_finalization=wait_for_finalization,
             )
-            extrinsic_response.extrinsic_receipt = response
+
             # We only wait here if we expect finalization.
             if not wait_for_finalization and not wait_for_inclusion:
                 extrinsic_response.extrinsic_fee = await self.get_extrinsic_fee(
@@ -5631,6 +5667,8 @@ async def sign_and_send_extrinsic(
                 logging.debug(extrinsic_response.message)
                 return extrinsic_response
 
+            extrinsic_response.extrinsic_receipt = response
+
             if await response.is_success:
                 extrinsic_response.extrinsic_fee = Balance.from_rao(
                     await response.total_fee_amount

bittensor/core/extrinsics/asyncex/proxy.py

@@ -1,7 +1,9 @@
+import asyncio
 from typing import TYPE_CHECKING, Optional, Union
 
 from bittensor.core.chain_data.proxy import ProxyType
 from bittensor.core.extrinsics.pallets import Proxy
+from bittensor.core.extrinsics.utils import apply_pure_proxy_data
 from bittensor.core.types import ExtrinsicResponse
 from bittensor.utils.btlogging import logging
 
@@ -42,6 +44,13 @@ async def add_proxy_extrinsic(
 
     Returns:
         ExtrinsicResponse: The result object of the extrinsic execution.
+
+    Warning:
+        If ``wait_for_inclusion=False`` or when ``block_hash`` is not available, the extrinsic receipt may not contain
+        triggered events. This means that any data that would normally be extracted from blockchain events (such as
+        proxy relationship details) will not be available in the response. To ensure complete event data is available,
+        either pass ``wait_for_inclusion=True`` when calling this function, or retrieve the data manually from the
+        blockchain using the extrinsic hash.
     """
     try:
         if not (
@@ -273,23 +282,30 @@ async def create_pure_proxy_extrinsic(
         if response.success:
             logging.debug("[green]Pure proxy created successfully.[/green]")
 
-            # Extract pure proxy address from PureCreated triggered event
-            for event in await response.extrinsic_receipt.triggered_events:
-                if event.get("event_id") == "PureCreated":
-                    # Event structure: PureProxyCreated { disambiguation_index, proxy_type, pure, who }
-                    attributes = event.get("attributes", [])
-                    if attributes:
-                        response.data = {
-                            "pure_account": attributes.get("pure"),
-                            "spawner": attributes.get("who"),
-                            "proxy_type": attributes.get("proxy_type"),
-                            "index": attributes.get("disambiguation_index"),
-                            "height": await subtensor.substrate.get_block_number(
-                                response.extrinsic_receipt.block_hash
-                            ),
-                            "ext_index": await response.extrinsic_receipt.extrinsic_idx,
-                        }
-                    break
+            block_hash = (
+                response.extrinsic_receipt.block_hash
+                if response.extrinsic_receipt
+                else None
+            )
+
+            block_number, triggered_events, extrinsic_idx = (
+                await asyncio.gather(
+                    subtensor.substrate.get_block_number(block_hash=block_hash),
+                    response.extrinsic_receipt.triggered_events,
+                    response.extrinsic_receipt.extrinsic_idx,
+                )
+                if (wait_for_finalization or wait_for_inclusion)
+                and response.extrinsic_receipt.block_hash
+                else (0, [], 0)
+            )
+
+            response = apply_pure_proxy_data(
+                response=response,
+                triggered_events=triggered_events,
+                block_number=block_number,
+                extrinsic_idx=extrinsic_idx,
+                raise_error=raise_error,
+            )
         else:
             logging.error(f"[red]{response.message}[/red]")
 

bittensor/core/extrinsics/proxy.py

@@ -2,6 +2,7 @@
 
 from bittensor.core.chain_data.proxy import ProxyType
 from bittensor.core.extrinsics.pallets import Proxy
+from bittensor.core.extrinsics.utils import apply_pure_proxy_data
 from bittensor.core.types import ExtrinsicResponse
 from bittensor.utils.btlogging import logging
 
@@ -239,6 +240,13 @@ def create_pure_proxy_extrinsic(
 
     Returns:
         ExtrinsicResponse: The result object of the extrinsic execution.
+
+    Warning:
+        If ``wait_for_inclusion=False`` or when ``block_hash`` is not available, the extrinsic receipt may not contain
+        triggered events. This means that any data that would normally be extracted from blockchain events (such as
+        proxy relationship details) will not be available in the response. To ensure complete event data is available,
+        either pass ``wait_for_inclusion=True`` when calling this function, or retrieve the data manually from the
+        blockchain using the extrinsic hash.
     """
     try:
         if not (
@@ -272,23 +280,28 @@ def create_pure_proxy_extrinsic(
         if response.success:
             logging.debug("[green]Pure proxy created successfully.[/green]")
 
-            # Extract pure proxy address from PureCreated triggered event
-            for event in response.extrinsic_receipt.triggered_events:
-                if event.get("event_id") == "PureCreated":
-                    # Event structure: PureProxyCreated { disambiguation_index, proxy_type, pure, who }
-                    attributes = event.get("attributes", [])
-                    if attributes:
-                        response.data = {
-                            "pure_account": attributes.get("pure"),
-                            "spawner": attributes.get("who"),
-                            "proxy_type": attributes.get("proxy_type"),
-                            "index": attributes.get("disambiguation_index"),
-                            "height": subtensor.substrate.get_block_number(
-                                response.extrinsic_receipt.block_hash
-                            ),
-                            "ext_index": response.extrinsic_receipt.extrinsic_idx,
-                        }
-                    break
+            block_number, triggered_events, extrinsic_idx = (
+                (
+                    subtensor.substrate.get_block_number(
+                        block_hash=response.extrinsic_receipt.block_hash
+                        if response.extrinsic_receipt
+                        else None
+                    ),
+                    response.extrinsic_receipt.triggered_events,
+                    response.extrinsic_receipt.extrinsic_idx,
+                )
+                if (wait_for_finalization or wait_for_inclusion)
+                and response.extrinsic_receipt.block_hash
+                else (0, [], 0)
+            )
+
+            response = apply_pure_proxy_data(
+                response=response,
+                triggered_events=triggered_events,
+                block_number=block_number,
+                extrinsic_idx=extrinsic_idx,
+                raise_error=raise_error,
+            )
         else:
             logging.error(f"[red]{response.message}[/red]")
 

bittensor/core/extrinsics/utils.py

@@ -145,3 +145,65 @@ def sudo_call_extrinsic(
 
     except Exception as error:
         return ExtrinsicResponse.from_exception(raise_error=raise_error, error=error)
+
+
+def apply_pure_proxy_data(
+    response: ExtrinsicResponse,
+    triggered_events: list,
+    block_number: int,
+    extrinsic_idx: int,
+    raise_error: bool,
+) -> ExtrinsicResponse:
+    """Apply pure proxy data to the response object.
+
+    Parameters:
+        response: The response object to update.
+        triggered_events: The triggered events of the transaction.
+        block_number: The block number of the transaction.
+        extrinsic_idx: The index of the extrinsic in the transaction.
+        raise_error: Whether to raise an error if the data cannot be applied successfully.
+
+    Returns:
+        True if the data was applied successfully, False otherwise.
+    """
+    # Extract pure proxy address from PureCreated triggered event if wait_for_inclusion is True.
+    for event in triggered_events:
+        if event.get("event_id") == "PureCreated":
+            # Event structure: PureProxyCreated { disambiguation_index, proxy_type, pure, who }
+            attributes = event.get("attributes", [])
+            if attributes:
+                response.data = {
+                    "pure_account": attributes.get("pure"),
+                    "spawner": attributes.get("who"),
+                    "proxy_type": attributes.get("proxy_type"),
+                    "index": attributes.get("disambiguation_index"),
+                    "height": block_number,
+                    "ext_index": extrinsic_idx,
+                }
+            return response
+
+    # If triggered events are not available or event PureCreated does not exist in the response, return the response
+    # with warning message ot raise the error if raise_error is True.
+    message = (
+        f"The ExtrinsicResponse doesn't contain pure_proxy data (`pure_account`, `spawner`, `proxy_type`, etc.) "
+        f"because the extrinsic receipt doesn't have triggered events. This typically happens when "
+        f"`wait_for_inclusion=False` or when `block_hash` is not available. To get this data, either pass "
+        f"`wait_for_inclusion=True` when calling this function, or retrieve the data manually from the blockchain "
+        f"using the extrinsic hash."
+    )
+    if response.extrinsic is not None and hasattr(response.extrinsic, "extrinsic_hash"):
+        extrinsic_hash = response.extrinsic.extrinsic_hash
+        hash_str = (
+            extrinsic_hash.hex()
+            if hasattr(extrinsic_hash, "hex")
+            else str(extrinsic_hash)
+        )
+        message += f" Extrinsic hash: `{hash_str}`"
+
+    response.success = False
+    response.message = message
+
+    if raise_error:
+        raise RuntimeError(message)
+
+    return response.with_log("warning")

bittensor/core/subtensor.py

@@ -3176,7 +3176,7 @@ def get_stake_info_for_coldkey(
             block: The block number at which to query the stake information.
 
         Returns:
-            An optional list of StakeInfo objects, or ``None`` if no stake information is found.
+            List of StakeInfo objects.
         """
         result = self.query_runtime_api(
             runtime_api="StakeInfoRuntimeApi",
@@ -3187,8 +3187,35 @@ def get_stake_info_for_coldkey(
 
         if result is None:
             return []
-        stakes: list[StakeInfo] = StakeInfo.list_from_dicts(result)
-        return [stake for stake in stakes if stake.stake > 0]
+        return StakeInfo.list_from_dicts(result)
+
+    def get_stake_info_for_coldkeys(
+        self, coldkey_ss58s: list[str], block: Optional[int] = None
+    ) -> dict[str, list["StakeInfo"]]:
+        """
+        Retrieves the stake information for multiple coldkeys.
+
+        Parameters:
+            coldkey_ss58s: A list of SS58 addresses of the coldkeys to query.
+            block: The block number at which to query the stake information.
+
+        Returns:
+            The dictionary mapping coldkey addresses to a list of StakeInfo objects.
+        """
+        query = self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_info_for_coldkeys",
+            params=[coldkey_ss58s],
+            block=block,
+        )
+
+        if query is None:
+            return {}
+
+        return {
+            decode_account_id(ck): StakeInfo.list_from_dicts(st_info)
+            for ck, st_info in query
+        }
 
     def get_stake_for_hotkey(
         self, hotkey_ss58: str, netuid: int, block: Optional[int] = None
@@ -4530,7 +4557,7 @@ def sign_and_send_extrinsic(
                 wait_for_inclusion=wait_for_inclusion,
                 wait_for_finalization=wait_for_finalization,
             )
-            extrinsic_response.extrinsic_receipt = response
+
             # We only wait here if we expect finalization.
             if not wait_for_finalization and not wait_for_inclusion:
                 extrinsic_response.extrinsic_fee = self.get_extrinsic_fee(
@@ -4542,6 +4569,8 @@ def sign_and_send_extrinsic(
                 logging.debug(extrinsic_response.message)
                 return extrinsic_response
 
+            extrinsic_response.extrinsic_receipt = response
+
             if response.is_success:
                 extrinsic_response.extrinsic_fee = Balance.from_rao(
                     response.total_fee_amount

bittensor/core/types.py

@@ -352,9 +352,7 @@ class ExtrinsicResponse:
     extrinsic_function: Optional[str] = None
     extrinsic: Optional["GenericExtrinsic"] = None
     extrinsic_fee: Optional["Balance"] = None
-    extrinsic_receipt: Optional[Union["ExtrinsicReceipt", "AsyncExtrinsicReceipt"]] = (
-        None
-    )
+    extrinsic_receipt: Optional["AsyncExtrinsicReceipt | ExtrinsicReceipt"] = None
     transaction_tao_fee: Optional["Balance"] = None
     transaction_alpha_fee: Optional["Balance"] = None
     error: Optional[Exception] = None

bittensor/extras/subtensor_api/staking.py

@@ -24,6 +24,7 @@ def __init__(self, subtensor: Union["_Subtensor", "_AsyncSubtensor"]):
             subtensor.get_stake_for_coldkey_and_hotkey
         )
         self.get_stake_info_for_coldkey = subtensor.get_stake_info_for_coldkey
+        self.get_stake_info_for_coldkeys = subtensor.get_stake_info_for_coldkeys
         self.get_stake_movement_fee = subtensor.get_stake_movement_fee
         self.get_stake_weight = subtensor.get_stake_weight
         self.get_unstake_fee = subtensor.get_unstake_fee