bittensor-cli 9.0.3__py3-none-any.whl → 9.1.0__py3-none-any.whl

bittensor_cli/cli.py

@@ -32,7 +32,7 @@ from bittensor_cli.version import __version__, __version_as_int__
 from bittensor_cli.src.bittensor import utils
 from bittensor_cli.src.bittensor.balances import Balance
 from async_substrate_interface.errors import SubstrateRequestException
-from bittensor_cli.src.commands import sudo, wallets
+from bittensor_cli.src.commands import sudo, wallets, view
 from bittensor_cli.src.commands import weights as weights_cmds
 from bittensor_cli.src.commands.subnets import price, subnets
 from bittensor_cli.src.commands.stake import (
@@ -193,8 +193,7 @@ class Options:
     )
     wait_for_finalization = typer.Option(
         True,
-        help="If `True`, waits until the transaction is finalized "
-        "on the blockchain.",
+        help="If `True`, waits until the transaction is finalized on the blockchain.",
     )
     prompt = typer.Option(
         True,
@@ -513,6 +512,7 @@ class CLIManager:
     subnets_app: typer.Typer
     weights_app: typer.Typer
     utils_app = typer.Typer(epilog=_epilog)
+    view_app: typer.Typer
     asyncio_runner = asyncio
 
     def __init__(self):
@@ -562,6 +562,7 @@ class CLIManager:
         self.sudo_app = typer.Typer(epilog=_epilog)
         self.subnets_app = typer.Typer(epilog=_epilog)
         self.weights_app = typer.Typer(epilog=_epilog)
+        self.view_app = typer.Typer(epilog=_epilog)
 
         # config alias
         self.app.add_typer(
@@ -639,6 +640,14 @@ class CLIManager:
             self.utils_app, name="utils", no_args_is_help=True, hidden=True
         )
 
+        # view app
+        self.app.add_typer(
+            self.view_app,
+            name="view",
+            short_help="HTML view commands",
+            no_args_is_help=True,
+        )
+
         # config commands
         self.config_app.command("set")(self.set_config)
         self.config_app.command("get")(self.get_config)
@@ -806,6 +815,11 @@ class CLIManager:
             "commit", rich_help_panel=HELP_PANELS["WEIGHTS"]["COMMIT_REVEAL"]
         )(self.weights_commit)
 
+        # view commands
+        self.view_app.command(
+            "dashboard", rich_help_panel=HELP_PANELS["VIEW"]["DASHBOARD"]
+        )(self.view_dashboard)
+
         # Sub command aliases
         # Weights
         self.wallet_app.command(
@@ -1336,7 +1350,7 @@ class CLIManager:
                     if value in Constants.networks:
                         value = value + f" ({Constants.network_map[value]})"
             if key == "rate_tolerance":
-                value = f"{value} ({value*100}%)" if value is not None else "None"
+                value = f"{value} ({value * 100}%)" if value is not None else "None"
 
             elif key in deprecated_configs:
                 continue
@@ -1365,19 +1379,19 @@ class CLIManager:
         """
         if rate_tolerance is not None:
             console.print(
-                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{rate_tolerance} ({rate_tolerance*100}%)[/bold cyan]."
+                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{rate_tolerance} ({rate_tolerance * 100}%)[/bold cyan]."
             )
             return rate_tolerance
         elif self.config.get("rate_tolerance") is not None:
             config_slippage = self.config["rate_tolerance"]
             console.print(
-                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{config_slippage} ({config_slippage*100}%)[/bold cyan] (from config)."
+                f"[dim][blue]Rate tolerance[/blue]: [bold cyan]{config_slippage} ({config_slippage * 100}%)[/bold cyan] (from config)."
             )
             return config_slippage
         else:
             console.print(
                 "[dim][blue]Rate tolerance[/blue]: "
-                + f"[bold cyan]{defaults.rate_tolerance} ({defaults.rate_tolerance*100}%)[/bold cyan] "
+                + f"[bold cyan]{defaults.rate_tolerance} ({defaults.rate_tolerance * 100}%)[/bold cyan] "
                 + "by default. Set this using "
                 + "[dark_sea_green3 italic]`btcli config set`[/dark_sea_green3 italic] "
                 + "or "
@@ -5071,6 +5085,28 @@ class CLIManager:
             )
         )
 
+    def view_dashboard(
+        self,
+        network: Optional[list[str]] = Options.network,
+        wallet_name: str = Options.wallet_name,
+        wallet_path: str = Options.wallet_path,
+        wallet_hotkey: str = Options.wallet_hotkey,
+        quiet: bool = Options.quiet,
+        verbose: bool = Options.verbose,
+    ):
+        """
+        Display html dashboard with subnets list, stake, and neuron information.
+        """
+        self.verbosity_handler(quiet, verbose)
+        if is_linux():
+            print_linux_dependency_message()
+        wallet = self.wallet_ask(
+            wallet_name, wallet_path, wallet_hotkey, ask_for=[WO.NAME, WO.PATH]
+        )
+        return self._run_command(
+            view.display_network_dashboard(wallet, self.initialize_chain(network))
+        )
+
     @staticmethod
     @utils_app.command("convert")
     def convert(

bittensor_cli/src/__init__.py

@@ -713,6 +713,9 @@ HELP_PANELS = {
         "IDENTITY": "Subnet Identity Management",
     },
     "WEIGHTS": {"COMMIT_REVEAL": "Commit / Reveal"},
+    "VIEW": {
+        "DASHBOARD": "Network Dashboard",
+    },
 }
 
 COLOR_PALETTE = {

bittensor_cli/src/bittensor/balances.py

@@ -297,17 +297,16 @@ class Balance:
         return self
 
 
-def fixed_to_float(fixed: dict) -> float:
-    # Currently this is stored as a U64F64
+def fixed_to_float(fixed, frac_bits: int = 64, total_bits: int = 128) -> float:
+    # By default, this is a U64F64
     # which is 64 bits of integer and 64 bits of fractional
-    # uint_bits = 64
-    frac_bits = 64
 
     data: int = fixed["bits"]
 
-    # Shift bits to extract integer part (assuming 64 bits for integer part)
-    integer_part = data >> frac_bits
+    # Logical and to get the fractional part; remaining is the integer part
     fractional_part = data & (2**frac_bits - 1)
+    # Shift to get the integer part from the remaining bits
+    integer_part = data >> (total_bits - frac_bits)
 
     frac_float = fractional_part / (2**frac_bits)
 

bittensor_cli/src/bittensor/chain_data.py

@@ -6,11 +6,12 @@ from typing import Optional, Any, Union
 import netaddr
 from scalecodec.utils.ss58 import ss58_encode
 
-from bittensor_cli.src.bittensor.balances import Balance
+from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
 from bittensor_cli.src.bittensor.networking import int_to_ip
 from bittensor_cli.src.bittensor.utils import (
     SS58_FORMAT,
-    u16_normalized_float,
+    u16_normalized_float as u16tf,
+    u64_normalized_float as u64tf,
     decode_account_id,
 )
 
@@ -57,6 +58,31 @@ def process_stake_data(stake_data, netuid):
     return decoded_stake_data
 
 
+def _tbwu(val: int, netuid: Optional[int] = 0) -> Balance:
+    """Returns a Balance object from a value and unit."""
+    return Balance.from_rao(val).set_unit(netuid)
+
+
+def _chr_str(codes: tuple[int]) -> str:
+    """Converts a tuple of integer Unicode code points into a string."""
+    return "".join(map(chr, codes))
+
+
+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):
+            return [
+                {k: chr_transform(v) for k, v in item.items()}
+                if item is not None
+                else None
+                for item in data
+            ]
+        return {}
+    elif isinstance(data, dict):
+        return {k: chr_transform(v) for k, v in data.items()}
+
+
 @dataclass
 class AxonInfo:
     version: int
@@ -312,13 +338,13 @@ class NeuronInfo(InfoBase):
             stake=total_stake,
             stake_dict=stake_dict,
             total_stake=total_stake,
-            rank=u16_normalized_float(decoded.get("rank")),
+            rank=u16tf(decoded.get("rank")),
             emission=decoded.get("emission") / 1e9,
-            incentive=u16_normalized_float(decoded.get("incentive")),
-            consensus=u16_normalized_float(decoded.get("consensus")),
-            trust=u16_normalized_float(decoded.get("trust")),
-            validator_trust=u16_normalized_float(decoded.get("validator_trust")),
-            dividends=u16_normalized_float(decoded.get("dividends")),
+            incentive=u16tf(decoded.get("incentive")),
+            consensus=u16tf(decoded.get("consensus")),
+            trust=u16tf(decoded.get("trust")),
+            validator_trust=u16tf(decoded.get("validator_trust")),
+            dividends=u16tf(decoded.get("dividends")),
             last_update=decoded.get("last_update"),
             validator_permit=decoded.get("validator_permit"),
             weights=[[e[0], e[1]] for e in decoded.get("weights")],
@@ -426,22 +452,22 @@ class NeuronInfoLite(InfoBase):
                 coldkey=coldkey,
             ),
             coldkey=coldkey,
-            consensus=u16_normalized_float(consensus),
-            dividends=u16_normalized_float(dividends),
+            consensus=u16tf(consensus),
+            dividends=u16tf(dividends),
             emission=emission / 1e9,
             hotkey=hotkey,
-            incentive=u16_normalized_float(incentive),
+            incentive=u16tf(incentive),
             last_update=last_update,
             netuid=netuid,
             pruning_score=pruning_score,
-            rank=u16_normalized_float(rank),
+            rank=u16tf(rank),
             stake_dict=stake_dict,
             stake=stake,
             total_stake=stake,
-            trust=u16_normalized_float(trust),
+            trust=u16tf(trust),
             uid=uid,
             validator_permit=validator_permit,
-            validator_trust=u16_normalized_float(validator_trust),
+            validator_trust=u16tf(validator_trust),
         )
 
         return neuron
@@ -492,7 +518,7 @@ class DelegateInfo(InfoBase):
             total_stake=total_stake,
             nominators=nominators,
             owner_ss58=owner,
-            take=u16_normalized_float(decoded.get("take")),
+            take=u16tf(decoded.get("take")),
             validator_permits=decoded.get("validator_permits"),
             registrations=decoded.get("registrations"),
             return_per_1000=Balance.from_rao(decoded.get("return_per_1000")),
@@ -528,7 +554,7 @@ class DelegateInfoLite(InfoBase):
         if decoded_take == 65535:
             fixed_take = None
         else:
-            fixed_take = u16_normalized_float(decoded_take)
+            fixed_take = u16tf(decoded_take)
 
         return cls(
             hotkey_ss58=ss58_encode(decoded.get("delegate_ss58"), SS58_FORMAT),
@@ -581,7 +607,7 @@ class SubnetInfo(InfoBase):
             tempo=decoded.get("tempo"),
             modality=decoded.get("network_modality"),
             connection_requirements={
-                str(int(netuid)): u16_normalized_float(int(req))
+                str(int(netuid)): u16tf(int(req))
                 for (netuid, req) in decoded.get("network_connect")
             },
             emission_value=decoded.get("emission_value"),
@@ -844,19 +870,17 @@ class SubnetState(InfoBase):
             coldkeys=[decode_account_id(val) for val in decoded.get("coldkeys")],
             active=decoded.get("active"),
             validator_permit=decoded.get("validator_permit"),
-            pruning_score=[
-                u16_normalized_float(val) for val in decoded.get("pruning_score")
-            ],
+            pruning_score=[u16tf(val) for val in decoded.get("pruning_score")],
             last_update=decoded.get("last_update"),
             emission=[
                 Balance.from_rao(val).set_unit(netuid)
                 for val in decoded.get("emission")
             ],
-            dividends=[u16_normalized_float(val) for val in decoded.get("dividends")],
-            incentives=[u16_normalized_float(val) for val in decoded.get("incentives")],
-            consensus=[u16_normalized_float(val) for val in decoded.get("consensus")],
-            trust=[u16_normalized_float(val) for val in decoded.get("trust")],
-            rank=[u16_normalized_float(val) for val in decoded.get("rank")],
+            dividends=[u16tf(val) for val in decoded.get("dividends")],
+            incentives=[u16tf(val) for val in decoded.get("incentives")],
+            consensus=[u16tf(val) for val in decoded.get("consensus")],
+            trust=[u16tf(val) for val in decoded.get("trust")],
+            rank=[u16tf(val) for val in decoded.get("rank")],
             block_at_registration=decoded.get("block_at_registration"),
             alpha_stake=[
                 Balance.from_rao(val).set_unit(netuid)
@@ -871,3 +895,241 @@ class SubnetState(InfoBase):
             ],
             emission_history=decoded.get("emission_history"),
         )
+
+
+@dataclass
+class ChainIdentity(InfoBase):
+    """Dataclass for chain identity information."""
+
+    name: str
+    url: str
+    github: str
+    image: str
+    discord: str
+    description: str
+    additional: str
+
+    @classmethod
+    def _from_dict(cls, decoded: dict) -> "ChainIdentity":
+        """Returns a ChainIdentity object from decoded chain data."""
+        return cls(
+            name=decoded["name"],
+            url=decoded["url"],
+            github=decoded["github_repo"],
+            image=decoded["image"],
+            discord=decoded["discord"],
+            description=decoded["description"],
+            additional=decoded["additional"],
+        )
+
+
+@dataclass
+class MetagraphInfo(InfoBase):
+    # Subnet index
+    netuid: int
+
+    # Name and symbol
+    name: str
+    symbol: str
+    identity: Optional[SubnetIdentity]
+    network_registered_at: int
+
+    # Keys for owner.
+    owner_hotkey: str  # hotkey
+    owner_coldkey: str  # coldkey
+
+    # Tempo terms.
+    block: int  # block at call.
+    tempo: int  # epoch tempo
+    last_step: int
+    blocks_since_last_step: int
+
+    # Subnet emission terms
+    subnet_emission: Balance  # subnet emission via tao
+    alpha_in: Balance  # amount of alpha in reserve
+    alpha_out: Balance  # amount of alpha outstanding
+    tao_in: Balance  # amount of tao injected per block
+    alpha_out_emission: Balance  # amount injected in alpha reserves per block
+    alpha_in_emission: Balance  # amount injected outstanding per block
+    tao_in_emission: Balance  # amount of tao injected per block
+    pending_alpha_emission: Balance  # pending alpha to be distributed
+    pending_root_emission: Balance  # pending tao for root divs to be distributed
+    subnet_volume: Balance  # volume of the subnet in TAO
+    moving_price: Balance  # subnet moving price.
+
+    # Hparams for epoch
+    rho: int  # subnet rho param
+    kappa: float  # subnet kappa param
+
+    # Validator params
+    min_allowed_weights: float  # min allowed weights per val
+    max_weights_limit: float  # max allowed weights per val
+    weights_version: int  # allowed weights version
+    weights_rate_limit: int  # rate limit on weights.
+    activity_cutoff: int  # validator weights cut off period in blocks
+    max_validators: int  # max allowed validators.
+
+    # Registration
+    num_uids: int
+    max_uids: int
+    burn: Balance  # current burn cost.
+    difficulty: float  # current difficulty.
+    registration_allowed: bool  # allows registrations.
+    pow_registration_allowed: bool  # pow registration enabled.
+    immunity_period: int  # subnet miner immunity period
+    min_difficulty: float  # min pow difficulty
+    max_difficulty: float  # max pow difficulty
+    min_burn: Balance  # min tao burn
+    max_burn: Balance  # max tao burn
+    adjustment_alpha: float  # adjustment speed for registration params.
+    adjustment_interval: int  # pow and burn adjustment interval
+    target_regs_per_interval: int  # target registrations per interval
+    max_regs_per_block: int  # max registrations per block.
+    serving_rate_limit: int  # axon serving rate limit
+
+    # CR
+    commit_reveal_weights_enabled: bool  # Is CR enabled.
+    commit_reveal_period: int  # Commit reveal interval
+
+    # Bonds
+    liquid_alpha_enabled: bool  # Bonds liquid enabled.
+    alpha_high: float  # Alpha param high
+    alpha_low: float  # Alpha param low
+    bonds_moving_avg: float  # Bonds moving avg
+
+    # Metagraph info.
+    hotkeys: list[str]  # hotkey per UID
+    coldkeys: list[str]  # coldkey per UID
+    identities: list[Optional[ChainIdentity]]  # coldkeys identities
+    axons: list[AxonInfo]  # UID axons.
+    active: list[bool]  # Active per UID
+    validator_permit: list[bool]  # Val permit per UID
+    pruning_score: list[float]  # Pruning per UID
+    last_update: list[int]  # Last update per UID
+    emission: list[Balance]  # Emission per UID
+    dividends: list[float]  # Dividends per UID
+    incentives: list[float]  # Mining incentives per UID
+    consensus: list[float]  # Consensus per UID
+    trust: list[float]  # Trust per UID
+    rank: list[float]  # Rank per UID
+    block_at_registration: list[int]  # Reg block per UID
+    alpha_stake: list[Balance]  # Alpha staked per UID
+    tao_stake: list[Balance]  # TAO staked per UID
+    total_stake: list[Balance]  # Total stake per UID
+
+    # Dividend break down.
+    tao_dividends_per_hotkey: list[
+        tuple[str, Balance]
+    ]  # List of dividend payouts in tao via root.
+    alpha_dividends_per_hotkey: list[
+        tuple[str, Balance]
+    ]  # List of dividend payout in alpha via subnet.
+
+    @classmethod
+    def _fix_decoded(cls, decoded: dict) -> "MetagraphInfo":
+        """Returns a MetagraphInfo object from decoded chain data."""
+        # Subnet index
+        _netuid = decoded["netuid"]
+
+        # Name and symbol
+        decoded.update({"name": bytes(decoded.get("name")).decode()})
+        decoded.update({"symbol": bytes(decoded.get("symbol")).decode()})
+        for key in ["identities", "identity"]:
+            raw_data = decoded.get(key)
+            processed = process_nested(raw_data, _chr_str)
+            decoded.update({key: processed})
+
+        return cls(
+            # Subnet index
+            netuid=_netuid,
+            # Name and symbol
+            name=decoded["name"],
+            symbol=decoded["symbol"],
+            identity=decoded["identity"],
+            network_registered_at=decoded["network_registered_at"],
+            # Keys for owner.
+            owner_hotkey=decoded["owner_hotkey"],
+            owner_coldkey=decoded["owner_coldkey"],
+            # Tempo terms.
+            block=decoded["block"],
+            tempo=decoded["tempo"],
+            last_step=decoded["last_step"],
+            blocks_since_last_step=decoded["blocks_since_last_step"],
+            # Subnet emission terms
+            subnet_emission=_tbwu(decoded["subnet_emission"]),
+            alpha_in=_tbwu(decoded["alpha_in"], _netuid),
+            alpha_out=_tbwu(decoded["alpha_out"], _netuid),
+            tao_in=_tbwu(decoded["tao_in"]),
+            alpha_out_emission=_tbwu(decoded["alpha_out_emission"], _netuid),
+            alpha_in_emission=_tbwu(decoded["alpha_in_emission"], _netuid),
+            tao_in_emission=_tbwu(decoded["tao_in_emission"]),
+            pending_alpha_emission=_tbwu(decoded["pending_alpha_emission"], _netuid),
+            pending_root_emission=_tbwu(decoded["pending_root_emission"]),
+            subnet_volume=_tbwu(decoded["subnet_volume"], _netuid),
+            moving_price=Balance.from_tao(
+                fixed_to_float(decoded.get("moving_price"), 32)
+            ),
+            # Hparams for epoch
+            rho=decoded["rho"],
+            kappa=decoded["kappa"],
+            # Validator params
+            min_allowed_weights=u16tf(decoded["min_allowed_weights"]),
+            max_weights_limit=u16tf(decoded["max_weights_limit"]),
+            weights_version=decoded["weights_version"],
+            weights_rate_limit=decoded["weights_rate_limit"],
+            activity_cutoff=decoded["activity_cutoff"],
+            max_validators=decoded["max_validators"],
+            # Registration
+            num_uids=decoded["num_uids"],
+            max_uids=decoded["max_uids"],
+            burn=_tbwu(decoded["burn"]),
+            difficulty=u64tf(decoded["difficulty"]),
+            registration_allowed=decoded["registration_allowed"],
+            pow_registration_allowed=decoded["pow_registration_allowed"],
+            immunity_period=decoded["immunity_period"],
+            min_difficulty=u64tf(decoded["min_difficulty"]),
+            max_difficulty=u64tf(decoded["max_difficulty"]),
+            min_burn=_tbwu(decoded["min_burn"]),
+            max_burn=_tbwu(decoded["max_burn"]),
+            adjustment_alpha=u64tf(decoded["adjustment_alpha"]),
+            adjustment_interval=decoded["adjustment_interval"],
+            target_regs_per_interval=decoded["target_regs_per_interval"],
+            max_regs_per_block=decoded["max_regs_per_block"],
+            serving_rate_limit=decoded["serving_rate_limit"],
+            # CR
+            commit_reveal_weights_enabled=decoded["commit_reveal_weights_enabled"],
+            commit_reveal_period=decoded["commit_reveal_period"],
+            # Bonds
+            liquid_alpha_enabled=decoded["liquid_alpha_enabled"],
+            alpha_high=u16tf(decoded["alpha_high"]),
+            alpha_low=u16tf(decoded["alpha_low"]),
+            bonds_moving_avg=u64tf(decoded["bonds_moving_avg"]),
+            # Metagraph info.
+            hotkeys=[decode_account_id(ck) for ck in decoded.get("hotkeys", [])],
+            coldkeys=[decode_account_id(hk) for hk in decoded.get("coldkeys", [])],
+            identities=decoded["identities"],
+            axons=decoded.get("axons", []),
+            active=decoded["active"],
+            validator_permit=decoded["validator_permit"],
+            pruning_score=[u16tf(ps) for ps in decoded.get("pruning_score", [])],
+            last_update=decoded["last_update"],
+            emission=[_tbwu(em, _netuid) for em in decoded.get("emission", [])],
+            dividends=[u16tf(dv) for dv in decoded.get("dividends", [])],
+            incentives=[u16tf(ic) for ic in decoded.get("incentives", [])],
+            consensus=[u16tf(cs) for cs in decoded.get("consensus", [])],
+            trust=[u16tf(tr) for tr in decoded.get("trust", [])],
+            rank=[u16tf(rk) for rk in decoded.get("rank", [])],
+            block_at_registration=decoded["block_at_registration"],
+            alpha_stake=[_tbwu(ast, _netuid) for ast in decoded["alpha_stake"]],
+            tao_stake=[_tbwu(ts) for ts in decoded["tao_stake"]],
+            total_stake=[_tbwu(ts, _netuid) for ts in decoded["total_stake"]],
+            # Dividend break down
+            tao_dividends_per_hotkey=[
+                (decode_account_id(alpha[0]), _tbwu(alpha[1]))
+                for alpha in decoded["tao_dividends_per_hotkey"]
+            ],
+            alpha_dividends_per_hotkey=[
+                (decode_account_id(adphk[0]), _tbwu(adphk[1], _netuid))
+                for adphk in decoded["alpha_dividends_per_hotkey"]
+            ],
+        )

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -20,6 +20,7 @@ from bittensor_cli.src.bittensor.chain_data import (
     decode_hex_identity,
     DynamicInfo,
     SubnetState,
+    MetagraphInfo,
 )
 from bittensor_cli.src import DelegatesDetails
 from bittensor_cli.src.bittensor.balances import Balance, fixed_to_float
@@ -1252,6 +1253,38 @@ class SubtensorInterface:
         else:
             return Balance.from_rao(_result).set_unit(int(netuid))
 
+    async def get_metagraph_info(
+        self, netuid: int, block_hash: Optional[str] = None
+    ) -> Optional[MetagraphInfo]:
+        hex_bytes_result = await self.query_runtime_api(
+            runtime_api="SubnetInfoRuntimeApi",
+            method="get_metagraph",
+            params=[netuid],
+            block_hash=block_hash,
+        )
+
+        if hex_bytes_result is None:
+            return None
+
+        try:
+            bytes_result = bytes.fromhex(hex_bytes_result[2:])
+        except ValueError:
+            bytes_result = bytes.fromhex(hex_bytes_result)
+
+        return MetagraphInfo.from_any(bytes_result)
+
+    async def get_all_metagraphs_info(
+        self, block_hash: Optional[str] = None
+    ) -> list[MetagraphInfo]:
+        hex_bytes_result = await self.query_runtime_api(
+            runtime_api="SubnetInfoRuntimeApi",
+            method="get_all_metagraphs",
+            params=[],
+            block_hash=block_hash,
+        )
+
+        return MetagraphInfo.list_from_any(hex_bytes_result)
+
     async def multi_get_stake_for_coldkey_and_hotkey_on_netuid(
         self,
         hotkey_ss58s: list[str],

bittensor_cli/src/bittensor/utils.py

@@ -1279,14 +1279,25 @@ def print_linux_dependency_message():
     """Prints the WebKit dependency message for Linux systems."""
     console.print("[red]This command requires WebKit dependencies on Linux.[/red]")
     console.print(
-        "\nPlease install the required packages using one of the following commands based on your distribution:"
+        "\nPlease make sure these packages are installed on your system for PyWry to work:"
     )
     console.print("\nArch Linux / Manjaro:")
     console.print("[green]sudo pacman -S webkit2gtk[/green]")
     console.print("\nDebian / Ubuntu:")
     console.print("[green]sudo apt install libwebkit2gtk-4.0-dev[/green]")
+    console.print("\nNote for Ubuntu 24.04+ & Debian 13+:")
+    console.print("You may need these additional steps to install libwebkit2gtk:")
+    console.print(
+        "\tCreate a new source file with: [green]sudo vim /etc/apt/sources.list.d/jammy-temp.list[/green]"
+    )
+    console.print(
+        "\tAdd this into the file and save: [green]deb http://archive.ubuntu.com/ubuntu jammy main universe[/green]"
+    )
+    console.print(
+        "\tUpdate the repository and install the webkit dependency: [green]sudo apt update && sudo apt install libwebkit2gtk-4.0-dev[/green]"
+    )
     console.print("\nFedora / CentOS / AlmaLinux:")
-    console.print("[green]sudo dnf install gtk3-devel webkit2gtk3-devel[/green]")
+    console.print("[green]sudo dnf install gtk3-devel webkit2gtk3-devel[/green]\n\n")
 
 
 def is_linux():

bittensor_cli/src/commands/stake/move.py

@@ -335,8 +335,7 @@ async def stake_move_selection(
 
 
 async def stake_transfer_selection(
-    wallet: Wallet,
-    subtensor: "SubtensorInterface",
+    wallet: Wallet, subtensor: "SubtensorInterface", origin_hotkey: str
 ):
     """Selection interface for transferring stakes."""
     (
@@ -353,7 +352,7 @@ async def stake_transfer_selection(
 
     available_stakes = {}
     for stake in stakes:
-        if stake.stake.tao > 0 and stake.hotkey_ss58 == wallet.hotkey.ss58_address:
+        if stake.stake.tao > 0 and stake.hotkey_ss58 == origin_hotkey:
             available_stakes[stake.netuid] = {
                 "hotkey_ss58": stake.hotkey_ss58,
                 "stake": stake.stake,
@@ -718,8 +717,9 @@ async def transfer_stake(
     Returns:
         bool: True if transfer was successful, False otherwise.
     """
+    origin_hotkey = origin_hotkey or wallet.hotkey.ss58_address
     if interactive_selection:
-        selection = await stake_transfer_selection(wallet, subtensor)
+        selection = await stake_transfer_selection(wallet, subtensor, origin_hotkey)
         origin_netuid = selection["origin_netuid"]
         amount = selection["amount"]
         dest_netuid = selection["destination_netuid"]