meshtensor-cli 9.27.3__tar.gz → 9.28.0__tar.gz

{meshtensor_cli-9.27.3 → meshtensor_cli-9.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshtensor-cli
-Version: 9.27.3
+Version: 9.28.0
 Summary: Meshtensor CLI
 Author: meshtensor.com
 Requires-Python: >=3.9

{meshtensor_cli-9.27.3 → meshtensor_cli-9.28.0}/meshtensor_cli/cli.py

@@ -3907,7 +3907,7 @@ class CLIManager:
         #     if self.config.get("network") != "swarm":
         #         console.print(no_use_config_str)
 
-        # For Rao games
+        # For Meshlet games
         print_error("This command is disabled on the 'meshlet' network.")
         raise typer.Exit()
 
@@ -4942,22 +4942,22 @@ class CLIManager:
                     exit_early=False,
                 )
             logger.debug(f"Free balance: {free_balance}")
-            if free_balance == Balance.from_tao(0):
+            if free_balance == Balance.from_mesh(0):
                 print_error("You dont have any balance to stake.")
                 return
             if netuids:
                 amount = FloatPrompt.ask(
-                    f"Amount to [{COLORS.G.SUBHEAD_MAIN}]stake (MESH τ)"
+                    f"Amount to [{COLORS.G.SUBHEAD_MAIN}]stake (MESH μ)"
                 )
             else:
                 amount = FloatPrompt.ask(
-                    f"Amount to [{COLORS.G.SUBHEAD_MAIN}]stake to each netuid (MESH τ)"
+                    f"Amount to [{COLORS.G.SUBHEAD_MAIN}]stake to each netuid (MESH μ)"
                 )
 
             if amount <= 0:
                 print_error(f"You entered an incorrect stake amount: {amount}")
                 raise typer.Exit()
-            if Balance.from_tao(amount) > free_balance:
+            if Balance.from_mesh(amount) > free_balance:
                 print_error(
                     f"You dont have enough balance to stake. Current free Balance: {free_balance}."
                 )
@@ -7431,11 +7431,11 @@ class CLIManager:
 
         [bold]Output Columns:[/bold]
          • [white]Netuid[/white] - Subnet identifier number
-         • [white]Name[/white] - Subnet name with currency symbol (τ/α/β etc)
-         • [white]Price (τ_in/α_in)[/white] - Exchange rate (MESH per alpha token)
+         • [white]Name[/white] - Subnet name with currency symbol (μ/α/β etc)
+         • [white]Price (μ_in/α_in)[/white] - Exchange rate (MESH per alpha token)
          • [white]Market Cap (α * Price)[/white] - Total value in MESH (alpha tokens × price)
-         • [white]Emission (τ)[/white] - MESH rewards emitted per block to subnet
-         • [white]P (τ_in, α_in)[/white] - Pool reserves (Tao reserves, alpha reserves) in liquidity pool
+         • [white]Emission (μ)[/white] - MESH rewards emitted per block to subnet
+         • [white]P (μ_in, α_in)[/white] - Pool reserves (Mesh reserves, alpha reserves) in liquidity pool
          • [white]Stake (α_out)[/white] - Total staked alpha tokens across all hotkeys (alpha outstanding)
          • [white]Supply (α)[/white] - Circulating alpha token supply
          • [white]Tempo (k/n)[/white] - Block interval for subnet updates
@@ -8135,7 +8135,7 @@ class CLIManager:
 
         - [bold]UID[/bold]: Unique identifier of the neuron.
 
-        - [bold]STAKE(τ)[/bold]: Total stake of the neuron in MESH (τ).
+        - [bold]STAKE(μ)[/bold]: Total stake of the neuron in MESH (μ).
 
         - [bold]RANK[/bold]: Rank score of the neuron.
 
@@ -8187,7 +8187,7 @@ class CLIManager:
             )
             raise typer.Exit()
 
-        # For Rao games
+        # For Meshlet games
         effective_network = get_effective_network(self.config, network)
         if is_meshlet_network(effective_network):
             print_error("This command is disabled on the 'meshlet' network.")
@@ -8602,18 +8602,18 @@ class CLIManager:
         )
         # Determine the liquidity amount.
         if liquidity_:
-            liquidity_ = Balance.from_tao(liquidity_)
+            liquidity_ = Balance.from_mesh(liquidity_)
         else:
             liquidity_ = prompt_liquidity("Enter the amount of liquidity")
 
         # Determine price range
         if price_low:
-            price_low = Balance.from_tao(price_low)
+            price_low = Balance.from_mesh(price_low)
         else:
             price_low = prompt_liquidity("Enter liquidity position low price")
 
         if price_high:
-            price_high = Balance.from_tao(price_high)
+            price_high = Balance.from_mesh(price_high)
         else:
             price_high = prompt_liquidity(
                 "Enter liquidity position high price (must be greater than low price)"
@@ -8809,7 +8809,7 @@ class CLIManager:
             position_id = prompt_position_id()
 
         if liquidity_delta:
-            liquidity_delta = Balance.from_tao(liquidity_delta)
+            liquidity_delta = Balance.from_mesh(liquidity_delta)
         else:
             liquidity_delta = prompt_liquidity(
                 f"Enter the [blue]liquidity delta[/blue] to modify position with id "
@@ -9144,9 +9144,9 @@ class CLIManager:
                 meshtensor=self.initialize_chain(network),
                 wallet=wallet,
                 proxy=proxy,
-                deposit_tao=deposit,
-                min_contribution_tao=min_contribution,
-                cap_tao=cap,
+                deposit_mesh=deposit,
+                min_contribution_mesh=min_contribution,
+                cap_mesh=cap,
                 duration_blocks=duration,
                 target_address=target_address,
                 subnet_lease=subnet_lease,
@@ -9415,9 +9415,9 @@ class CLIManager:
         )
 
         min_contribution_balance = (
-            Balance.from_tao(min_contribution) if min_contribution is not None else None
+            Balance.from_mesh(min_contribution) if min_contribution is not None else None
         )
-        cap_balance = Balance.from_tao(cap) if cap is not None else None
+        cap_balance = Balance.from_mesh(cap) if cap is not None else None
 
         return self._run_command(
             crowd_update.update_crowdloan(
@@ -10099,17 +10099,17 @@ class CLIManager:
     @staticmethod
     def convert(
         from_meshlet: Optional[str] = typer.Option(
-            None, "--meshlet", help="Convert amount from Rao"
+            None, "--meshlet", help="Convert amount from Meshlet"
         ),
-        from_tao: Optional[float] = typer.Option(
-            None, "--tao", help="Convert amount from Tao"
+        from_mesh: Optional[float] = typer.Option(
+            None, "--mesh", help="Convert amount from Mesh"
         ),
     ):
         """
         Allows for converting between mesh and meshlet using the specified flags
         """
-        if from_tao is None and from_meshlet is None:
-            print_error("Specify `--meshlet` and/or `--tao`.")
+        if from_mesh is None and from_meshlet is None:
+            print_error("Specify `--meshlet` and/or `--mesh`.")
             raise typer.Exit()
         if from_meshlet is not None:
             meshlet = int(float(from_meshlet))
@@ -10118,12 +10118,12 @@ class CLIManager:
                 "=",
                 Balance.from_meshlet(meshlet),
             )
-        if from_tao is not None:
-            mesh = float(from_tao)
+        if from_mesh is not None:
+            mesh = float(from_mesh)
             console.print(
-                f"{Balance.unit}{tao}",
+                f"{Balance.unit}{mesh}",
                 "=",
-                f"{Balance.from_tao(tao).meshlet}{Balance.meshlet_unit}",
+                f"{Balance.from_mesh(mesh).meshlet}{Balance.meshlet_unit}",
             )
 
     def best_connection(

{meshtensor_cli-9.27.3 → meshtensor_cli-9.28.0}/meshtensor_cli/src/__init__.py

@@ -359,7 +359,7 @@ UNITS = [
     b"\xe0\xb8\x92".decode(),  # ฒ (Tho Phuthao, 184)
     b"\xe0\xb8\x93".decode(),  # ณ (No Nen, 185)
     b"\xe0\xb8\x94".decode(),  # ด (Do Dek, 186)
-    b"\xe0\xb8\x95".decode(),  # ต (To Tao, 187)
+    b"\xe0\xb8\x95".decode(),  # ต (To Mesh, 187)
     b"\xe0\xb8\x96".decode(),  # ถ (Tho Thung, 188)
     b"\xe0\xb8\x97".decode(),  # ท (Tho Thahan, 189)
     b"\xe0\xb8\x98".decode(),  # ธ (Tho Thong, 190)

{meshtensor_cli-9.27.3 → meshtensor_cli-9.28.0}/meshtensor_cli/src/bittensor/balances.py

@@ -1,5 +1,5 @@
 # The MIT License (MIT)
-# Copyright © 2021-2022 Yuma Rao
+# Copyright © 2021-2022 Yuma Meshlet
 # Copyright © 2022 Grobb
 # Copyright © 2023 Grobb
 
@@ -24,24 +24,24 @@ from meshtensor_cli.src import UNITS
 class Balance:
     """
     Represents the meshtensor balance of the wallet, stored as meshlet (int).
-    This class provides a way to interact with balances in two different units: meshlet and tao.
+    This class provides a way to interact with balances in two different units: meshlet and mesh.
     It provides methods to convert between these units, as well as to perform arithmetic and comparison operations.
 
     :var unit: A string representing the symbol for the mesh unit.
     :var meshlet_unit: A string representing the symbol for the meshlet unit.
     :var meshlet: An integer that stores the balance in meshlet units.
-    :var tao: A float property that gives the balance in mesh units.
+    :var mesh: A float property that gives the balance in mesh units.
     """
 
-    unit: str = chr(0x03C4)  # This is the mesh unit
+    unit: str = chr(0x03BC)  # This is the mesh unit
     meshlet_unit: str = chr(0x03C1)  # This is the meshlet unit
     meshlet: int
-    tao: float
+    mesh: float
 
     def __init__(self, balance: Union[int, float]):
         """
         Initialize a Balance object. If balance is an int, it's assumed to be in meshlet.
-        If balance is a float, it's assumed to be in tao.
+        If balance is a float, it's assumed to be in mesh.
 
         :param balance: The initial balance, in either meshlet (if an int) or mesh (if a float).
         """
@@ -51,10 +51,10 @@ class Balance:
             # Assume mesh value for the float
             self.meshlet = int(balance * pow(10, 9))
         else:
-            raise TypeError("balance must be an int (meshlet) or a float (tao)")
+            raise TypeError("balance must be an int (meshlet) or a float (mesh)")
 
     @property
-    def tao(self):
+    def mesh(self):
         return self.meshlet / pow(10, 9)
 
     def __int__(self):
@@ -65,24 +65,24 @@ class Balance:
 
     def __float__(self):
         """
-        Convert the Balance object to a float. The resulting value is in tao.
+        Convert the Balance object to a float. The resulting value is in mesh.
         """
-        return self.tao
+        return self.mesh
 
     def __str__(self):
         """
-        Returns the Balance object as a string in the format "symbolvalue", where the value is in tao.
+        Returns the Balance object as a string in the format "symbolvalue", where the value is in mesh.
         """
         if self.unit == UNITS[0]:
-            return f"{self.unit} {float(self.tao):,.4f}"
+            return f"{self.unit} {float(self.mesh):,.4f}"
         else:
-            return f"\u200e{float(self.tao):,.4f} {self.unit}\u200e"
+            return f"\u200e{float(self.mesh):,.4f} {self.unit}\u200e"
 
     def __rich__(self):
         return "[green]{}[/green][green]{}[/green][green].[/green][dim green]{}[/dim green]".format(
             self.unit,
-            format(float(self.tao), "f").split(".")[0],
-            format(float(self.tao), "f").split(".")[1],
+            format(float(self.mesh), "f").split(".")[0],
+            format(float(self.mesh), "f").split(".")[1],
         )
 
     def __str_meshlet__(self):
@@ -211,7 +211,7 @@ class Balance:
 
     def __floordiv__(self, other: Union[int, float, "Balance"]):
         if hasattr(other, "meshlet"):
-            return Balance.from_meshlet(int(self.tao // other.tao))
+            return Balance.from_meshlet(int(self.mesh // other.mesh))
         else:
             try:
                 # Attempt to cast to int from meshlet
@@ -242,13 +242,13 @@ class Balance:
         return Balance.from_meshlet(abs(self.meshlet))
 
     def to_dict(self) -> dict:
-        return {"meshlet": self.meshlet, "mesh": self.tao}
+        return {"meshlet": self.meshlet, "mesh": self.mesh}
 
     @staticmethod
     def from_float(amount: float):
         """
-        Given mesh (float), return Balance object with meshlet(int) and tao(float), where meshlet = int(tao*pow(10,9))
-        :param amount: The amount in tao.
+        Given mesh (float), return Balance object with meshlet(int) and mesh(float), where meshlet = int(mesh*pow(10,9))
+        :param amount: The amount in mesh.
 
         :return: A Balance object representing the given amount.
         """
@@ -256,11 +256,11 @@ class Balance:
         return Balance(meshlet)
 
     @staticmethod
-    def from_tao(amount: float):
+    def from_mesh(amount: float):
         """
-        Given mesh (float), return Balance object with meshlet(int) and tao(float), where meshlet = int(tao*pow(10,9))
+        Given mesh (float), return Balance object with meshlet(int) and mesh(float), where meshlet = int(mesh*pow(10,9))
 
-        :param amount: The amount in tao.
+        :param amount: The amount in mesh.
 
         :return: A Balance object representing the given amount.
         """
@@ -270,7 +270,7 @@ class Balance:
     @staticmethod
     def from_meshlet(amount: int):
         """
-        Given meshlet (int), return Balance object with meshlet(int) and tao(float), where meshlet = int(tao*pow(10,9))
+        Given meshlet (int), return Balance object with meshlet(int) and mesh(float), where meshlet = int(mesh*pow(10,9))
 
         :param amount: The amount in meshlet.
 

{meshtensor_cli-9.27.3 → meshtensor_cli-9.28.0}/meshtensor_cli/src/bittensor/chain_data.py

@@ -274,7 +274,7 @@ class StakeInfo(InfoBase):
     stake: Balance  # Stake for the hotkey-coldkey pair
     locked: Balance  # Stake which is locked.
     emission: Balance  # Emission for the hotkey-coldkey pair
-    tao_emission: Balance  # MESH emission for the hotkey-coldkey pair
+    mesh_emission: Balance  # MESH emission for the hotkey-coldkey pair
     drain: int
     is_registered: bool
 
@@ -286,7 +286,7 @@ class StakeInfo(InfoBase):
         stake = Balance.from_meshlet(decoded.get("stake")).set_unit(netuid)
         locked = Balance.from_meshlet(decoded.get("locked")).set_unit(netuid)
         emission = Balance.from_meshlet(decoded.get("emission")).set_unit(netuid)
-        tao_emission = Balance.from_meshlet(decoded.get("tao_emission"))
+        mesh_emission = Balance.from_meshlet(decoded.get("mesh_emission"))
         drain = int(decoded.get("drain"))
         is_registered = bool(decoded.get("is_registered"))
 
@@ -297,7 +297,7 @@ class StakeInfo(InfoBase):
             stake,
             locked,
             emission,
-            tao_emission,
+            mesh_emission,
             drain,
             is_registered,
         )
@@ -707,13 +707,13 @@ class DynamicInfo(InfoBase):
     emission: Balance
     alpha_in: Balance
     alpha_out: Balance
-    tao_in: Balance
+    mesh_in: Balance
     price: Balance
     k: float
     is_dynamic: bool
     alpha_out_emission: Balance
     alpha_in_emission: Balance
-    tao_in_emission: Balance
+    mesh_in_emission: Balance
     pending_alpha_emission: Balance
     pending_root_emission: Balance
     network_registered_at: int
@@ -736,7 +736,7 @@ class DynamicInfo(InfoBase):
         emission = Balance.from_meshlet(decoded.get("emission")).set_unit(0)
         alpha_in = Balance.from_meshlet(decoded.get("alpha_in")).set_unit(netuid)
         alpha_out = Balance.from_meshlet(decoded.get("alpha_out")).set_unit(netuid)
-        tao_in = Balance.from_meshlet(decoded.get("tao_in")).set_unit(0)
+        mesh_in = Balance.from_meshlet(decoded.get("mesh_in")).set_unit(0)
         alpha_out_emission = Balance.from_meshlet(
             decoded.get("alpha_out_emission")
         ).set_unit(netuid)
@@ -744,7 +744,7 @@ class DynamicInfo(InfoBase):
             netuid
         )
         subnet_volume = Balance.from_meshlet(decoded.get("subnet_volume")).set_unit(netuid)
-        tao_in_emission = Balance.from_meshlet(decoded.get("tao_in_emission")).set_unit(0)
+        mesh_in_emission = Balance.from_meshlet(decoded.get("mesh_in_emission")).set_unit(0)
         pending_alpha_emission = Balance.from_meshlet(
             decoded.get("pending_alpha_emission")
         ).set_unit(netuid)
@@ -752,11 +752,11 @@ class DynamicInfo(InfoBase):
             decoded.get("pending_root_emission")
         ).set_unit(0)
         price = (
-            Balance.from_tao(1.0)
+            Balance.from_mesh(1.0)
             if netuid == 0
-            else Balance.from_tao(tao_in.tao / alpha_in.tao)
-            if alpha_in.tao > 0
-            else Balance.from_tao(1)
+            else Balance.from_mesh(mesh_in.mesh / alpha_in.mesh)
+            if alpha_in.mesh > 0
+            else Balance.from_mesh(1)
         )  # TODO: Patching this temporarily for netuid 0
 
         if decoded.get("subnet_identity"):
@@ -776,13 +776,13 @@ class DynamicInfo(InfoBase):
             emission=emission,
             alpha_in=alpha_in,
             alpha_out=alpha_out,
-            tao_in=tao_in,
-            k=tao_in.meshlet * alpha_in.meshlet,
+            mesh_in=mesh_in,
+            k=mesh_in.meshlet * alpha_in.meshlet,
             is_dynamic=is_dynamic,
             price=price,
             alpha_out_emission=alpha_out_emission,
             alpha_in_emission=alpha_in_emission,
-            tao_in_emission=tao_in_emission,
+            mesh_in_emission=mesh_in_emission,
             pending_alpha_emission=pending_alpha_emission,
             pending_root_emission=pending_root_emission,
             network_registered_at=int(decoded.get("network_registered_at")),
@@ -791,34 +791,34 @@ class DynamicInfo(InfoBase):
             moving_price=fixed_to_float(decoded["moving_price"], 32),
         )
 
-    def tao_to_alpha(self, tao: Balance) -> Balance:
-        if self.price.tao != 0:
-            return Balance.from_tao(tao.tao / self.price.tao).set_unit(self.netuid)
+    def mesh_to_alpha(self, mesh: Balance) -> Balance:
+        if self.price.mesh != 0:
+            return Balance.from_mesh(mesh.mesh / self.price.mesh).set_unit(self.netuid)
         else:
-            return Balance.from_tao(0)
+            return Balance.from_mesh(0)
 
-    def alpha_to_tao(self, alpha: Balance) -> Balance:
-        return Balance.from_tao(alpha.tao * self.price.tao)
+    def alpha_to_mesh(self, alpha: Balance) -> Balance:
+        return Balance.from_mesh(alpha.mesh * self.price.mesh)
 
-    def tao_to_alpha_with_slippage(
-        self, tao: Balance
+    def mesh_to_alpha_with_slippage(
+        self, mesh: Balance
     ) -> tuple[Balance, Balance, float]:
         """
         Returns an estimate of how much Alpha a staker would receive if they stake their mesh using the current pool
             state.
 
         Args:
-            tao: Amount of MESH to stake.
+            mesh: Amount of MESH to stake.
         Returns:
             Tuple of balances where the first part is the amount of Alpha received, and the
             second part (slippage) is the difference between the estimated amount and ideal
             amount as if there was no slippage
         """
         if self.is_dynamic:
-            new_tao_in = self.tao_in + tao
-            if new_tao_in == 0:
-                return tao, Balance.from_meshlet(0)
-            new_alpha_in = self.k / new_tao_in
+            new_mesh_in = self.mesh_in + mesh
+            if new_mesh_in == 0:
+                return mesh, Balance.from_meshlet(0)
+            new_alpha_in = self.k / new_mesh_in
 
             # Amount of alpha given to the staker
             alpha_returned = Balance.from_meshlet(
@@ -826,17 +826,17 @@ class DynamicInfo(InfoBase):
             ).set_unit(self.netuid)
 
             # Ideal conversion as if there is no slippage, just price
-            alpha_ideal = self.tao_to_alpha(tao)
+            alpha_ideal = self.mesh_to_alpha(mesh)
 
-            if alpha_ideal.tao > alpha_returned.tao:
-                slippage = Balance.from_tao(
-                    alpha_ideal.tao - alpha_returned.tao
+            if alpha_ideal.mesh > alpha_returned.mesh:
+                slippage = Balance.from_mesh(
+                    alpha_ideal.mesh - alpha_returned.mesh
                 ).set_unit(self.netuid)
             else:
-                slippage = Balance.from_tao(0)
+                slippage = Balance.from_mesh(0)
         else:
-            alpha_returned = tao.set_unit(self.netuid)
-            slippage = Balance.from_tao(0)
+            alpha_returned = mesh.set_unit(self.netuid)
+            slippage = Balance.from_mesh(0)
 
         slippage_pct_float = (
             100 * float(slippage) / float(slippage + alpha_returned)
@@ -845,7 +845,7 @@ class DynamicInfo(InfoBase):
         )
         return alpha_returned, slippage, slippage_pct_float
 
-    def alpha_to_tao_with_slippage(
+    def alpha_to_mesh_with_slippage(
         self, alpha: Balance
     ) -> tuple[Balance, Balance, float]:
         """
@@ -861,20 +861,20 @@ class DynamicInfo(InfoBase):
         """
         if self.is_dynamic:
             new_alpha_in = self.alpha_in + alpha
-            new_tao_reserve = self.k / new_alpha_in
+            new_mesh_reserve = self.k / new_alpha_in
             # Amount of MESH given to the unstaker
-            tao_returned = Balance.from_meshlet(self.tao_in - new_tao_reserve)
+            tao_returned = Balance.from_meshlet(self.mesh_in - new_mesh_reserve)
 
             # Ideal conversion as if there is no slippage, just price
-            tao_ideal = self.alpha_to_tao(alpha)
+            tao_ideal = self.alpha_to_mesh(alpha)
 
             if tao_ideal > tao_returned:
-                slippage = Balance.from_tao(tao_ideal.tao - tao_returned.tao)
+                slippage = Balance.from_mesh(tao_ideal.mesh - tao_returned.mesh)
             else:
-                slippage = Balance.from_tao(0)
+                slippage = Balance.from_mesh(0)
         else:
             tao_returned = alpha.set_unit(0)
-            slippage = Balance.from_tao(0)
+            slippage = Balance.from_mesh(0)
         slippage_pct_float = (
             100 * float(slippage) / float(slippage + tao_returned)
             if slippage + tao_returned != 0
@@ -918,7 +918,7 @@ class SubnetState(InfoBase):
     rank: list[float]
     block_at_registration: list[int]
     alpha_stake: list[Balance]
-    tao_stake: list[Balance]
+    mesh_stake: list[Balance]
     total_stake: list[Balance]
     emission_history: list[list[int]]
 
@@ -947,8 +947,8 @@ class SubnetState(InfoBase):
                 Balance.from_meshlet(val).set_unit(netuid)
                 for val in decoded.get("alpha_stake")
             ],
-            tao_stake=[
-                Balance.from_meshlet(val).set_unit(0) for val in decoded.get("tao_stake")
+            mesh_stake=[
+                Balance.from_meshlet(val).set_unit(0) for val in decoded.get("mesh_stake")
             ],
             total_stake=[
                 Balance.from_meshlet(val).set_unit(netuid)
@@ -1006,13 +1006,13 @@ class MetagraphInfo(InfoBase):
     blocks_since_last_step: int
 
     # Subnet emission terms
-    subnet_emission: Balance  # subnet emission via tao
+    subnet_emission: Balance  # subnet emission via mesh
     alpha_in: Balance  # amount of alpha in reserve
     alpha_out: Balance  # amount of alpha outstanding
-    tao_in: Balance  # amount of mesh injected per block
+    mesh_in: Balance  # amount of mesh 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 mesh injected per block
+    mesh_in_emission: Balance  # amount of mesh injected per block
     pending_alpha_emission: Balance  # pending alpha to be distributed
     pending_root_emission: Balance  # pending mesh for root divs to be distributed
     subnet_volume: Balance  # volume of the subnet in MESH
@@ -1075,7 +1075,7 @@ class MetagraphInfo(InfoBase):
     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]  # MESH staked per UID
+    mesh_stake: list[Balance]  # MESH staked per UID
     total_stake: list[Balance]  # Total stake per UID
 
     # Dividend break down.
@@ -1122,14 +1122,14 @@ class MetagraphInfo(InfoBase):
             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"]),
+            mesh_in=_tbwu(decoded["mesh_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"]),
+            mesh_in_emission=_tbwu(decoded["mesh_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(
+            moving_price=Balance.from_mesh(
                 fixed_to_float(decoded.get("moving_price"), 32)
             ),
             # Hparams for epoch
@@ -1184,7 +1184,7 @@ class MetagraphInfo(InfoBase):
             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"]],
+            mesh_stake=[_tbwu(ts) for ts in decoded["mesh_stake"]],
             total_stake=[_tbwu(ts, _netuid) for ts in decoded["total_stake"]],
             # Dividend break down
             tao_dividends_per_hotkey=[
@@ -1202,7 +1202,7 @@ class MetagraphInfo(InfoBase):
 class SimSwapResult:
     tao_amount: Balance
     alpha_amount: Balance
-    tao_fee: Balance
+    mesh_fee: Balance
     alpha_fee: Balance
 
     @classmethod
@@ -1210,7 +1210,7 @@ class SimSwapResult:
         return cls(
             tao_amount=Balance.from_meshlet(d.get("mesh_amount", d.get("tao_amount", 0))).set_unit(0),
             alpha_amount=Balance.from_meshlet(d["alpha_amount"]).set_unit(netuid),
-            tao_fee=Balance.from_meshlet(d.get("mesh_fee", d.get("tao_fee", 0))).set_unit(0),
+            mesh_fee=Balance.from_meshlet(d.get("mesh_fee", d.get("mesh_fee", 0))).set_unit(0),
             alpha_fee=Balance.from_meshlet(d["alpha_fee"]).set_unit(netuid),
         )
 

{meshtensor_cli-9.27.3/meshtensor_cli/src/meshtensor → meshtensor_cli-9.28.0/meshtensor_cli/src/bittensor}/extrinsics/root.py

@@ -1,5 +1,5 @@
 # The MIT License (MIT)
-# Copyright © 2021 Yuma Rao
+# Copyright © 2021 Yuma Meshlet
 # Copyright © 2023 Grobb
 # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 # documentation files (the “Software”), to deal in the Software without restriction, including without limitation

{meshtensor_cli-9.27.3/meshtensor_cli/src/meshtensor → meshtensor_cli-9.28.0/meshtensor_cli/src/bittensor}/minigraph.py

@@ -148,8 +148,8 @@ class MiniGraph:
         for neuron in neurons:
             idx = hotkey_to_index.get(neuron.hotkey)
             if idx is not None:
-                global_stake_list.append(subnet_state.global_stake[idx].tao)
-                local_stake_list.append(subnet_state.local_stake[idx].tao)
+                global_stake_list.append(subnet_state.global_stake[idx].mesh)
+                local_stake_list.append(subnet_state.local_stake[idx].mesh)
                 stake_weights_list.append(subnet_state.stake_weight[idx])
             else:
                 global_stake_list.append(0.0)