Merge pull request opentensor#700 from opentensor/release/9.15.1

Release/9.15.1

Author: ibraheem-abe

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 9.15.1 /2025-11-04
+
+* Update/Subnet list ema by @ibraheem-abe in https://github.com/opentensor/btcli/pull/699
+
+**Full Changelog**: https://github.com/opentensor/btcli/compare/v9.15.0...v9.15.1
+
 ## 9.15.0 /2025-11-04
 
 * Stop running e2e tests on changelog branches by @thewhaleking in https://github.com/opentensor/btcli/pull/691

bittensor_cli/src/bittensor/subtensor_interface.py

@@ -2231,7 +2231,7 @@ async def get_all_subnet_ema_tao_inflow(
         self,
         block_hash: Optional[str] = None,
         page_size: int = 100,
-    ) -> dict[int, tuple[int, float]]:
+    ) -> dict[int, Balance]:
         """
         Query EMA TAO inflow for all subnets.
 
@@ -2243,20 +2243,23 @@ async def get_all_subnet_ema_tao_inflow(
             page_size: The page size for batch queries (default: 100).
 
         Returns:
-            Dict mapping netuid -> (block_number, Balance(EMA TAO inflow)).
+            Dict mapping netuid -> Balance(EMA TAO inflow).
         """
         query = await self.substrate.query_map(
             module="SubtensorModule",
             storage_function="SubnetEmaTaoFlow",
             page_size=page_size,
             block_hash=block_hash,
         )
-        tao_inflow_ema = {}
+        ema_map = {}
         async for netuid, value in query:
-            block_updated, _tao_ema = value
-            ema_value = fixed_to_float(_tao_ema)
-            tao_inflow_ema[netuid] = (block_updated, Balance.from_rao(ema_value))
-        return tao_inflow_ema
+            if not value:
+                ema_map[netuid] = Balance.from_rao(0)
+            else:
+                _, raw_ema_value = value
+                ema_value = fixed_to_float(raw_ema_value)
+                ema_map[netuid] = Balance.from_rao(ema_value)
+        return ema_map
 
     async def get_subnet_ema_tao_inflow(
         self,

bittensor_cli/src/commands/subnets/subnets.py

@@ -223,10 +223,11 @@ async def subnets_list(
 
     async def fetch_subnet_data():
         block_hash = await subtensor.substrate.get_chain_head()
-        subnets_, mechanisms, block_number_ = await asyncio.gather(
+        subnets_, mechanisms, block_number_, ema_tao_inflow = await asyncio.gather(
             subtensor.all_subnets(block_hash=block_hash),
             subtensor.get_all_subnet_mechanisms(block_hash=block_hash),
             subtensor.substrate.get_block_number(block_hash=block_hash),
+            subtensor.get_all_subnet_ema_tao_inflow(block_hash=block_hash),
         )
 
         # Sort subnets by market cap, keeping the root subnet in the first position
@@ -237,7 +238,7 @@ async def fetch_subnet_data():
             reverse=True,
         )
         sorted_subnets = [root_subnet] + other_subnets
-        return sorted_subnets, block_number_, mechanisms
+        return sorted_subnets, block_number_, mechanisms, ema_tao_inflow
 
     def calculate_emission_stats(
         subnets_: list, block_number_: int
@@ -259,43 +260,12 @@ def calculate_emission_stats(
             )
         return total_tao_emitted, percentage_string
 
-    def format_ema_tao_value(value: float, verbose: bool = False) -> str:
-        """
-        Format EMA TAO inflow value with adaptive precision.
-        """
-        import math
-
-        abs_value = abs(value)
-        if abs_value == 0:
-            return "0.00"
-        elif abs_value >= 1.0:
-            # Large values: 2-4 decimal places
-            return f"{abs_value:,.4f}" if verbose else f"{abs_value:,.2f}"
-        elif abs_value >= 0.01:
-            # Medium values: 4 decimal places
-            return f"{abs_value:.4f}"
-        else:
-            # Low values: upto 12 decimal places
-            decimal_places = -int(math.floor(math.log10(abs_value))) + 2
-            decimal_places = min(decimal_places, 12)
-            return f"{abs_value:.{decimal_places}f}"
-
-    def format_ema_flow_cell(ema_value: float) -> tuple[str, str]:
-        """
-        Format EMA TAO inflow value with adaptive precision.
-        """
-        if ema_value > 0:
-            return "pale_green3", "+"
-        elif ema_value < 0:
-            return "hot_pink3", "-"
-        else:
-            return "blue", ""
-
     def define_table(
         total_emissions: float,
         total_rate: float,
         total_netuids: int,
         tao_emission_percentage: str,
+        total_tao_flow_ema: float,
     ):
         defined_table = Table(
             title=f"\n[{COLOR_PALETTE['GENERAL']['HEADER']}]Subnets"
@@ -334,6 +304,12 @@ def define_table(
             justify="left",
             footer=f"τ {total_emissions}",
         )
+        defined_table.add_column(
+            f"[bold white]Net Inflow EMA ({Balance.get_unit(0)})",
+            style=COLOR_PALETTE["POOLS"]["ALPHA_OUT"],
+            justify="left",
+            footer=f"τ {total_tao_flow_ema}",
+        )
         defined_table.add_column(
             f"[bold white]P ({Balance.get_unit(0)}_in, {Balance.get_unit(1)}_in)",
             style=COLOR_PALETTE["STAKE"]["TAO"],
@@ -365,7 +341,7 @@ def define_table(
         return defined_table
 
     # Non-live mode
-    def _create_table(subnets_, block_number_, mechanisms):
+    def _create_table(subnets_, block_number_, mechanisms, ema_tao_inflow):
         rows = []
         _, percentage_string = calculate_emission_stats(subnets_, block_number_)
 
@@ -432,6 +408,12 @@ def _create_table(subnets_, block_number_, mechanisms):
             )
             emission_cell = f"τ {emission_tao:,.4f}"
 
+            if netuid in ema_tao_inflow:
+                ema_value = ema_tao_inflow[netuid].tao
+            else:
+                ema_value = 0.0
+            ema_flow_cell = f"τ {ema_value:,.4f}"
+
             price_cell = f"{price_value} τ/{symbol}"
             alpha_out_cell = (
                 f"{alpha_out_value} {symbol}"
@@ -455,6 +437,7 @@ def _create_table(subnets_, block_number_, mechanisms):
                     price_cell,  # Rate τ_in/α_in
                     market_cap_cell,  # Market Cap
                     emission_cell,  # Emission (τ)
+                    ema_flow_cell,  # EMA TAO Inflow (τ)
                     liquidity_cell,  # Liquidity (t_in, a_in)
                     alpha_out_cell,  # Stake α_out
                     supply_cell,  # Supply
@@ -469,22 +452,30 @@ def _create_table(subnets_, block_number_, mechanisms):
             ),
             4,
         )
+        total_tao_flow_ema = round(
+            sum(inflow.tao for inflow in ema_tao_inflow.values()), 4
+        )
         total_rate = round(
             sum(float(subnet.price.tao) for subnet in subnets_ if subnet.netuid != 0), 4
         )
         total_netuids = len(subnets_)
         defined_table = define_table(
-            total_emissions, total_rate, total_netuids, percentage_string
+            total_emissions,
+            total_rate,
+            total_netuids,
+            percentage_string,
+            total_tao_flow_ema,
         )
 
         for row in rows:
             defined_table.add_row(*row)
         return defined_table
 
-    def dict_table(subnets_, block_number_, mechanisms) -> dict:
+    def dict_table(subnets_, block_number_, mechanisms, ema_tao_inflow) -> dict:
         subnet_rows = {}
         total_tao_emitted, _ = calculate_emission_stats(subnets_, block_number_)
         total_emissions = 0.0
+        total_tao_flow_ema = 0.0
         total_rate = 0.0
         total_netuids = len(subnets_)
         emission_percentage = (total_tao_emitted / block_number_) * 100
@@ -511,12 +502,17 @@ def dict_table(subnets_, block_number_, mechanisms) -> dict:
                 ),
                 "sn_tempo": (subnet.tempo if netuid != 0 else None),
             }
+            tao_flow_ema = None
+            if netuid in ema_tao_inflow:
+                tao_flow_ema = ema_tao_inflow[netuid].tao
+                total_tao_flow_ema += tao_flow_ema.tao
             subnet_rows[netuid] = {
                 "netuid": netuid,
                 "subnet_name": subnet_name,
                 "price": price_value,
                 "market_cap": market_cap,
                 "emission": emission_tao,
+                "tao_flow_ema": tao_flow_ema,
                 "liquidity": {"tao_in": tao_in, "alpha_in": alpha_in},
                 "alpha_out": alpha_out,
                 "supply": supply,
@@ -529,12 +525,15 @@ def dict_table(subnets_, block_number_, mechanisms) -> dict:
             "total_rate": total_rate,
             "total_netuids": total_netuids,
             "emission_percentage": emission_percentage,
+            "total_tao_flow_ema": total_tao_flow_ema,
             "subnets": subnet_rows,
         }
         return output
 
     # Live mode
-    def create_table_live(subnets_, previous_data_, block_number_, mechanisms):
+    def create_table_live(
+        subnets_, previous_data_, block_number_, mechanisms, ema_tao_inflow
+    ):
         def format_cell(
             value, previous_value, unit="", unit_first=False, precision=4, millify=False
         ):
@@ -652,10 +651,15 @@ def format_liquidity_cell(
             market_cap = (subnet.alpha_in.tao + subnet.alpha_out.tao) * subnet.price.tao
             supply = subnet.alpha_in.tao + subnet.alpha_out.tao
 
+            tao_flow_ema = 0.0
+            if netuid in ema_tao_inflow:
+                tao_flow_ema = ema_tao_inflow[netuid].tao
+
             # Store current values for comparison
             current_data[netuid] = {
                 "market_cap": market_cap,
                 "emission_tao": emission_tao,
+                "tao_flow_ema": tao_flow_ema,
                 "alpha_out": subnet.alpha_out.tao,
                 "tao_in": subnet.tao_in.tao,
                 "alpha_in": subnet.alpha_in.tao,
@@ -684,6 +688,14 @@ def format_liquidity_cell(
                 precision=4,
             )
 
+            tao_flow_ema_cell = format_cell(
+                tao_flow_ema,
+                prev.get("tao_flow_ema"),
+                unit="τ",
+                unit_first=True,
+                precision=4,
+            )
+
             price_cell = format_cell(
                 subnet.price.tao,
                 prev.get("price"),
@@ -767,6 +779,7 @@ def format_liquidity_cell(
                     price_cell,  # Rate τ_in/α_in
                     market_cap_cell,  # Market Cap
                     emission_cell,  # Emission (τ)
+                    tao_flow_ema_cell,  # EMA TAO Inflow (τ)
                     liquidity_cell,  # Liquidity (t_in, a_in)
                     alpha_out_cell,  # Stake α_out
                     supply_cell,  # Supply
@@ -785,13 +798,22 @@ def format_liquidity_cell(
             if not verbose
             else f"{_total_emissions:,.2f}"
         )
-
+        _total_tao_flow_ema = sum(inflow.tao for inflow in ema_tao_inflow.values())
+        total_tao_flow_ema = (
+            f"{millify_tao(_total_tao_flow_ema)}"
+            if not verbose
+            else f"{_total_tao_flow_ema:,.2f}"
+        )
         total_rate = sum(subnet.price.tao for subnet in subnets_ if subnet.netuid != 0)
         total_rate = (
             f"{millify_tao(total_rate)}" if not verbose else f"{total_rate:,.2f}"
         )
         table = define_table(
-            total_emissions, total_rate, total_netuids, percentage_string
+            total_emissions,
+            total_rate,
+            total_netuids,
+            percentage_string,
+            total_tao_flow_ema,
         )
 
         for row in rows:
@@ -822,6 +844,7 @@ def format_liquidity_cell(
                         subnets,
                         block_number,
                         mechanisms,
+                        ema_tao_inflow,
                     ) = await fetch_subnet_data()
 
                     # Update block numbers
@@ -834,7 +857,7 @@ def format_liquidity_cell(
                     )
 
                     table, current_data = create_table_live(
-                        subnets, previous_data, block_number, mechanisms
+                        subnets, previous_data, block_number, mechanisms, ema_tao_inflow
                     )
                     previous_data = current_data
                     progress.reset(progress_task)
@@ -860,13 +883,15 @@ def format_liquidity_cell(
                 pass  # Ctrl + C
     else:
         # Non-live mode
-        subnets, block_number, mechanisms = await fetch_subnet_data()
+        subnets, block_number, mechanisms, ema_tao_inflow = await fetch_subnet_data()
         if json_output:
             json_console.print(
-                json.dumps(dict_table(subnets, block_number, mechanisms))
+                json.dumps(
+                    dict_table(subnets, block_number, mechanisms, ema_tao_inflow)
+                )
             )
         else:
-            table = _create_table(subnets, block_number, mechanisms)
+            table = _create_table(subnets, block_number, mechanisms, ema_tao_inflow)
             console.print(table)
 
         return
@@ -1490,8 +1515,8 @@ async def show_subnet(
                 f"{total_mech_line}"
                 f"\n  Owner: [{COLOR_PALETTE['GENERAL']['COLDKEY']}]{subnet_info.owner_coldkey}{' (' + owner_identity + ')' if owner_identity else ''}[/{COLOR_PALETTE['GENERAL']['COLDKEY']}]"
                 f"\n  Rate: [{COLOR_PALETTE['GENERAL']['HOTKEY']}]{subnet_info.price.tao:.4f} τ/{subnet_info.symbol}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]"
-                f"\n  EMA TAO Inflow: [{COLOR_PALETTE['STAKE']['TAO']}]τ {ema_tao_inflow.tao}[/{COLOR_PALETTE['STAKE']['TAO']}]"
-                f"\n  Emission: [{COLOR_PALETTE['GENERAL']['HOTKEY']}]τ {subnet_info.emission.tao:,.4f}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]"
+                f"\n  EMA TAO Inflow: [{COLOR_PALETTE['STAKE']['TAO']}]τ {ema_tao_inflow.tao:.4f}[/{COLOR_PALETTE['STAKE']['TAO']}]"
+                f"\n  Emission: [{COLOR_PALETTE['GENERAL']['HOTKEY']}]τ {subnet_info.tao_in_emission.tao:,.4f}[/{COLOR_PALETTE['GENERAL']['HOTKEY']}]"
                 f"\n  TAO Pool: [{COLOR_PALETTE['POOLS']['ALPHA_IN']}]τ {tao_pool}[/{COLOR_PALETTE['POOLS']['ALPHA_IN']}]"
                 f"\n  Alpha Pool: [{COLOR_PALETTE['POOLS']['ALPHA_IN']}]{alpha_pool} {subnet_info.symbol}[/{COLOR_PALETTE['POOLS']['ALPHA_IN']}]"
                 # f"\n  Stake: [{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]{subnet_info.alpha_out.tao:,.5f} {subnet_info.symbol}[/{COLOR_PALETTE['STAKE']['STAKE_ALPHA']}]"

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bittensor-cli"
-version = "9.15.0"
+version = "9.15.1"
 description = "Bittensor CLI"
 readme = "README.md"
 authors = [