Check-in

thewhaleking · thewhaleking · commit 35363e2a933e · 2024-10-15T16:54:18.000+02:00
diff --git a/bittensor_cli/src/bittensor/subtensor_interface.py b/bittensor_cli/src/bittensor/subtensor_interface.py
@@ -1205,3 +1205,41 @@ async def multi_get_stake_for_coldkey_and_hotkey_on_netuid(
             )
             results[hotkey_ss58][netuid] = value
         return results
+
+    async def get_stake_info_for_coldkeys(
+        self, coldkey_ss58_list: list[str], block_hash: Optional[str] = None
+    ) -> Optional[dict[str, list[StakeInfo]]]:
+        """
+        Retrieves stake information for a list of coldkeys. This function aggregates stake data for multiple
+        accounts, providing a collective view of their stakes and delegations.
+
+        Args:
+            coldkey_ss58_list: A list of SS58 addresses of the accounts' coldkeys.
+            block_hash: The blockchain block number for the query.
+
+        Returns:
+            A dictionary mapping each coldkey to a list of its StakeInfo objects.
+
+        This function is useful for analyzing the stake distribution and delegation patterns of multiple
+        accounts simultaneously, offering a broader perspective on network participation and investment strategies.
+        """
+        encoded_coldkeys = [
+            ss58_to_vec_u8(coldkey_ss58) for coldkey_ss58 in coldkey_ss58_list
+        ]
+
+        hex_bytes_result = await self.query_runtime_api(
+            runtime_api="StakeInfoRuntimeApi",
+            method="get_stake_info_for_coldkeys",
+            params=encoded_coldkeys,
+            block_hash=block_hash,
+        )
+
+        if hex_bytes_result is None:
+            return None
+
+        if hex_bytes_result.startswith("0x"):
+            bytes_result = bytes.fromhex(hex_bytes_result[2:])
+        else:
+            bytes_result = bytes.fromhex(hex_bytes_result)
+
+        return StakeInfo.list_of_tuple_from_vec_u8(bytes_result)  # type: ignore
diff --git a/bittensor_cli/src/commands/stake/stake.py b/bittensor_cli/src/commands/stake/stake.py
@@ -1597,9 +1597,9 @@ async def unstake(
 
 
 async def stake_list(wallet: Wallet, subtensor: "SubtensorInterface"):
-    substakes = subtensor.get_stake_info_for_coldkeys(
+    sub_stakes = (await subtensor.get_stake_info_for_coldkeys(
         coldkey_ss58_list=[wallet.coldkeypub.ss58_address]
-    )[wallet.coldkeypub.ss58_address]
+    ))[wallet.coldkeypub.ss58_address]
 
     # Get registered delegates details.
     registered_delegate_info = await subtensor.get_delegate_identities()
@@ -1616,10 +1616,142 @@ async def stake_list(wallet: Wallet, subtensor: "SubtensorInterface"):
     # Iterate over substakes and aggregate them by hotkey.
     hotkeys_to_substakes: dict[str, list[StakeInfo]] = {}
 
-    for substake in substakes:
+    for substake in sub_stakes:
         hotkey = substake.hotkey_ss58
         if substake.stake.rao == 0:
             continue
         if hotkey not in hotkeys_to_substakes:
             hotkeys_to_substakes[hotkey] = []
         hotkeys_to_substakes[hotkey].append(substake)
+
+        def table_substakes(hotkey: str, substakes: list[StakeInfo]):
+            # Create table structure.
+            name = registered_delegate_info[
+                       hotkey].name + f" ({hotkey})" if hotkey in registered_delegate_info else hotkey
+            rows = []
+            total_global_tao = Balance(0)
+            total_tao_value = Balance(0)
+            for substake in substakes:
+                netuid = substake.netuid
+                pool = dynamic_info[netuid]
+                symbol = f"{bittensor.Balance.get_unit(netuid)}"
+                price = "{:.4f}{}".format(pool.price.__float__(),
+                                          f" τ/{Balance.get_unit(netuid)}\u200E") if pool.is_dynamic else (
+                    f" 1.0000 τ/{symbol} ")
+                alpha_value = Balance.from_rao(int(substake.stake.rao)).set_unit(netuid)
+                locked_value = Balance.from_rao(int(substake.locked.rao)).set_unit(netuid)
+                tao_value = pool.alpha_to_tao(alpha_value)
+                total_tao_value += tao_value
+                swapped_tao_value, slippage = pool.alpha_to_tao_with_slippage(substake.stake)
+                if pool.is_dynamic:
+                    slippage_percentage = 100 * float(slippage) / float(
+                        slippage + swapped_tao_value) if slippage + swapped_tao_value != 0 else 0
+                    slippage_percentage = f"[dark_red]{slippage_percentage:.3f}%[/dark_red]"
+                else:
+                    slippage_percentage = '0.000%'
+                tao_locked = pool.tao_in
+                issuance = pool.alpha_out if pool.is_dynamic else tao_locked
+                per_block_emission = substake.emission.tao / ((emission_drain_tempo / pool.tempo) * pool.tempo)
+                if alpha_value.tao > 0.00009:
+                    if issuance.tao != 0:
+                        alpha_ownership = "{:.4f}".format((alpha_value.tao / issuance.tao) * 100)
+                        tao_ownership = bittensor.Balance.from_tao((alpha_value.tao / issuance.tao) * tao_locked.tao)
+                        total_global_tao += tao_ownership
+                    else:
+                        alpha_ownership = "0.0000"
+                        tao_ownership = "0.0000"
+                    rows.append([
+                        str(netuid),  # Number
+                        symbol,  # Symbol
+                        # f"[medium_purple]{tao_ownership}[/medium_purple] ([light_salmon3]{ alpha_ownership }[/light_salmon3][white]%[/white])", # Tao ownership.
+                        f"[medium_purple]{tao_ownership}[/medium_purple]",  # Tao ownership.
+                        # f"[dark_sea_green]{ alpha_value }", # Alpha value
+                        f"{substake.stake.tao:,.4f} {symbol}",
+                        f"{pool.price.tao:.4f} τ/{symbol}",
+                        f"[light_slate_blue]{tao_value}[/light_slate_blue]",  # Tao equiv
+                        f"[cadet_blue]{swapped_tao_value}[/cadet_blue] ({slippage_percentage})",  # Swap amount.
+                        # f"[light_salmon3]{ alpha_ownership }%[/light_salmon3]",  # Ownership.
+                        f"[bold cadet_blue]YES[/bold cadet_blue]" if substake.is_registered else f"[dark_red]NO[/dark_red]",
+                        # Registered.
+                        str(bittensor.Balance.from_tao(per_block_emission).set_unit(
+                            netuid)) if substake.is_registered else "[dark_red]N/A[/dark_red]",  # emission per block.
+                        f"[light_slate_blue]{locked_value}[/light_slate_blue]",  # Locked value
+                    ])
+            # table = Table(show_footer=True, pad_edge=False, box=None, expand=False, title=f"{name}")
+            table = Table(
+                title=f"[white]hotkey:[/white] [light_salmon3]{name}[/light_salmon3]\n",
+                width=bittensor.__console__.width - 5,
+                safe_box=True,
+                padding=(0, 1),
+                collapse_padding=False,
+                pad_edge=True,
+                expand=True,
+                show_header=True,
+                show_footer=True,
+                show_edge=False,
+                show_lines=False,
+                leading=0,
+                style="none",
+                row_styles=None,
+                header_style="bold",
+                footer_style="bold",
+                border_style="rgb(7,54,66)",
+                title_style="bold magenta",
+                title_justify="center",
+                highlight=False,
+            )
+            table.add_column("[white]Netuid", footer_style="overline white", style="grey89")
+            table.add_column("[white]Symbol", footer_style="white", style="light_goldenrod1", justify="right",
+                             width=5,
+                             no_wrap=True)
+            table.add_column(f"[white]TAO({Balance.unit})", style="aquamarine3", justify="right",
+                             footer=f"{total_global_tao}")
+            table.add_column(f"[white]Stake({Balance.get_unit(1)})", footer_style="overline white",
+                             style="green", justify="right")
+            table.add_column(f"[white]Rate({Balance.unit}/{Balance.get_unit(1)})",
+                             footer_style="white", style="light_goldenrod2", justify="center")
+            table.add_column(
+                f"[white]Value({bittensor.Balance.get_unit(1)} x {Balance.unit}/{Balance.get_unit(1)})",
+                footer_style="overline white", style="blue", justify="right", footer=f"{total_tao_value}")
+            table.add_column(f"[white]Swap({Balance.get_unit(1)}) -> {Balance.unit}",
+                             footer_style="overline white", style="white", justify="right")
+            # table.add_column(f"[white]Control({bittensor.Balance.get_unit(1)})", style="aquamarine3", justify="right")
+            table.add_column("[white]Registered", style="red", justify="right")
+            table.add_column(f"[white]Emission({Balance.get_unit(1)}/block)", style="aquamarine3",
+                             justify="right")
+            table.add_column(f"[white]Locked({Balance.get_unit(1)})", footer_style="overline white",
+                             style="green", justify="right")
+            for row in rows:
+                table.add_row(*row)
+            console.print(table)
+            return total_global_tao, total_tao_value
+
+        # Iterate over each hotkey and make a table
+        all_hotkeys_total_global_tao = Balance(0)
+        all_hotkeys_total_tao_value = Balance(0)
+        for hotkey in hotkeys_to_substakes.keys():
+            stake, value = table_substakes(hotkey, hotkeys_to_substakes[hotkey])
+            all_hotkeys_total_global_tao += stake
+            all_hotkeys_total_tao_value += value
+
+        console.print("\n\n")
+        console.print(
+            f"Wallet:\n  Coldkey SS58: [bold dark_green]{cli.config.coldkey_address}[/bold dark_green]\n  Free Balance: [aquamarine3]{balance}[/aquamarine3]\n  Total TAO ({bittensor.Balance.unit}): [aquamarine3]{all_hotkeys_total_global_tao}[/aquamarine3]\n  Total Value ({bittensor.Balance.unit}): [aquamarine3]{all_hotkeys_total_tao_value}[/aquamarine3]")
+        console.print(
+            """
+[bold white]Description[/bold white]:
+    Each table displays information about your coldkey's staking accounts with a hotkey. 
+    The header of the table displays the hotkey and the footer displays the total stake and total value of all your staking accounts. 
+    The columns of the table are as follows:
+        - [bold white]Netuid[/bold white]: The unique identifier for the subnet (its index).
+        - [bold white]Symbol[/bold white]: The symbol representing the subnet stake's unit.
+        - [bold white]TAO[/bold white]: The hotkey's TAO balance on this subnet. This is this hotkey's proportion of total TAO staked into the subnet divided by the hotkey's share of outstanding stake.
+        - [bold white]Stake[/bold white]: The hotkey's stake balance in subnets staking unit.
+        - [bold white]Rate[/bold white]: The rate of exchange between the subnet's staking unit and the subnet's TAO.
+        - [bold white]Value[/bold white]: The price of the hotkey's stake in TAO computed via the exchange rate.
+        - [bold white]Swap[/bold white]: The amount of TAO received when unstaking all of the hotkey's stake (with slippage).
+        - [bold white]Registered[/bold white]: Whether the hotkey is registered on this subnet.
+        - [bold white]Emission[/bold white]: If registered, the emission (in stake) attained by this hotkey on this subnet per block.
+        - [bold white]Locked[/bold white]: The total amount of stake locked (not able to be unstaked).
+"""
+        )
