meshtensor-cli 9.24.0__tar.gz → 9.26.0__tar.gz

{meshtensor_cli-9.24.0 → meshtensor_cli-9.26.0}/PKG-INFO

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

{meshtensor_cli-9.24.0 → meshtensor_cli-9.26.0}/meshtensor_cli/cli.py

@@ -125,7 +125,7 @@ except ImportError:
 
 
 logger = logging.getLogger("meshcli")
-_epilog = "Made with [bold red]:heart:[/bold red] by The Openτensor Foundaτion"
+_epilog = "Made with [bold red]:heart:[/bold red] by Grobb"
 
 np.set_printoptions(precision=8, suppress=True, floatmode="fixed")
 
@@ -1432,18 +1432,6 @@ class CLIManager:
         self.governance_app.command("signal-golr")(self.governance_signal_golr)
         self.governance_app.command("update-scores")(self.governance_update_scores)
         self.governance_app.command("distribute-rewards")(self.governance_distribute_rewards)
-        self.governance_app.command("claim-rewards")(self.governance_claim_rewards)
-        self.governance_app.command("submit-preimage")(self.governance_submit_preimage)
-        self.governance_app.command("set-track-coefficients")(self.governance_set_track_coefficients)
-        self.governance_app.command("set-config")(self.governance_set_config)
-        self.governance_app.command("set-golr-config")(self.governance_set_golr_config)
-        self.governance_app.command("prune-accounts")(self.governance_prune_accounts)
-        self.governance_app.command("endorse")(self.governance_endorse)
-        self.governance_app.command("cancel")(self.governance_cancel)
-        self.governance_app.command("approve-treasury")(self.governance_approve_treasury)
-        self.governance_app.command("status")(self.governance_status)
-        self.governance_app.command("my-rewards")(self.governance_my_rewards)
-        self.governance_app.command("my-delegations")(self.governance_my_delegations)
 
         # Treasury commands
         self.treasury_app.command("propose")(self.treasury_propose)
@@ -10485,11 +10473,6 @@ class CLIManager:
     def governance_history(
         self,
         network: Optional[list[str]] = Options.network,
-        limit: int = typer.Option(
-            20,
-            "--limit",
-            help="Maximum number of referenda to show.",
-        ),
         quiet: bool = Options.quiet,
         verbose: bool = Options.verbose,
         json_output: bool = Options.json_output,
@@ -10499,7 +10482,6 @@ class CLIManager:
         return self._run_command(
             governance.governance_history(
                 subtensor=self.initialize_chain(network),
-                limit=limit,
                 quiet=quiet,
                 verbose=verbose,
                 output_json=json_output,
@@ -10581,354 +10563,6 @@ class CLIManager:
             )
         )
 
-    def governance_claim_rewards(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Claim pending governance rewards from the reward pool."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_claim_rewards(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_submit_preimage(
-        self,
-        call_data: str = typer.Argument(
-            ...,
-            help="Hex-encoded SCALE bytes of the runtime call (with or without 0x prefix).",
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Submit a preimage of a runtime call on-chain."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_submit_preimage(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                call_data=call_data,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_track_coefficients(
-        self,
-        track_id: int = typer.Option(
-            ..., "--track", help="Governance track ID (0-5)."
-        ),
-        alpha: int = typer.Option(
-            ..., "--alpha", help="Quadratic stake weight (0-1000)."
-        ),
-        beta: int = typer.Option(
-            ..., "--beta", help="Contribution weight (0-1000)."
-        ),
-        gamma: int = typer.Option(
-            ..., "--gamma", help="Reserved/future weight (0-1000)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update VP formula coefficients for a governance track (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_track_coefficients(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                track_id=track_id,
-                alpha=alpha,
-                beta=beta,
-                gamma=gamma,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_config(
-        self,
-        min_contribution_floor: int = typer.Option(
-            ..., "--min-contribution-floor", help="Minimum CW floor (0-1000, default 150)."
-        ),
-        max_delegation_pct: int = typer.Option(
-            ..., "--max-delegation-pct", help="Max delegated VP per delegatee (0-1000, default 50)."
-        ),
-        delegation_factor: int = typer.Option(
-            ..., "--delegation-factor", help="Delegation decay factor (0-1000, default 900)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update core governance configuration parameters (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_config(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                min_contribution_floor=min_contribution_floor,
-                max_delegation_pct=max_delegation_pct,
-                delegation_factor=delegation_factor,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_set_golr_config(
-        self,
-        paralysis_days: int = typer.Option(
-            ..., "--paralysis-days", help="Days of inactivity before GoLR (min 30)."
-        ),
-        threshold_pct: int = typer.Option(
-            ..., "--threshold-pct", help="Validator supermajority percentage (0-100)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Update GoLR (Governance of Last Resort) parameters (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_set_golr_config(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                paralysis_days=paralysis_days,
-                threshold_pct=threshold_pct,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_prune_accounts(
-        self,
-        accounts: list[str] = typer.Option(
-            ..., "--accounts", help="SS58 addresses to prune (max 500)."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Prune governance storage for zero-balance accounts (Root-only)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_prune_accounts(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                accounts=accounts,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_endorse(
-        self,
-        ref_index: int = typer.Option(
-            ..., "--ref-index", help="Referendum index to endorse."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Endorse a referendum as a Technical Committee member."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_endorse(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                ref_index=ref_index,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_cancel(
-        self,
-        ref_index: int = typer.Option(
-            ..., "--ref-index", help="Referendum index to cancel."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Cancel an active referendum (requires root origin)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_cancel(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                ref_index=ref_index,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_approve_treasury(
-        self,
-        proposal_id: int = typer.Option(
-            ..., "--proposal-id", help="Treasury proposal ID to approve."
-        ),
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Approve a treasury proposal (requires root origin)."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_approve_treasury(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                proposal_id=proposal_id,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_status(
-        self,
-        network: Optional[list[str]] = Options.network,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display governance system status overview."""
-        self.verbosity_handler(quiet, verbose)
-        return self._run_command(
-            governance.governance_status(
-                subtensor=self.initialize_chain(network),
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_my_rewards(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display governance rewards and contribution score for your wallet."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_my_rewards(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
-    def governance_my_delegations(
-        self,
-        network: Optional[list[str]] = Options.network,
-        wallet_name: str = Options.wallet_name,
-        wallet_path: str = Options.wallet_path,
-        quiet: bool = Options.quiet,
-        verbose: bool = Options.verbose,
-    ):
-        """Display active governance delegations for your wallet."""
-        self.verbosity_handler(quiet, verbose)
-        wallet = self.wallet_ask(
-            wallet_name,
-            wallet_path,
-            ask_for=[WO.NAME, WO.PATH],
-            validate=WV.WALLET,
-        )
-        return self._run_command(
-            governance.governance_my_delegations(
-                subtensor=self.initialize_chain(network),
-                wallet=wallet,
-                quiet=quiet,
-                verbose=verbose,
-            )
-        )
-
     # =========================================================================
     # Treasury commands
     # =========================================================================

{meshtensor_cli-9.24.0 → meshtensor_cli-9.26.0}/meshtensor_cli/src/__init__.py

@@ -635,54 +635,54 @@ class RootSudoOnly(Enum):
 
 HYPERPARAMS = {
     # meshcli name: (meshtensor method, root-only enum)
-    "rho": ("sudo_set_rho", RootSudoOnly.FALSE),
-    "kappa": ("sudo_set_kappa", RootSudoOnly.TRUE),
-    "immunity_period": ("sudo_set_immunity_period", RootSudoOnly.FALSE),
-    "min_allowed_weights": ("sudo_set_min_allowed_weights", RootSudoOnly.FALSE),
-    "max_weights_limit": ("sudo_set_max_weight_limit", RootSudoOnly.FALSE),
-    "tempo": ("sudo_set_tempo", RootSudoOnly.TRUE),
-    "min_difficulty": ("sudo_set_min_difficulty", RootSudoOnly.TRUE),
-    "max_difficulty": ("sudo_set_max_difficulty", RootSudoOnly.FALSE),
-    "weights_version": ("sudo_set_weights_version_key", RootSudoOnly.FALSE),
-    "weights_rate_limit": ("sudo_set_weights_set_rate_limit", RootSudoOnly.TRUE),
-    "adjustment_interval": ("sudo_set_adjustment_interval", RootSudoOnly.TRUE),
-    "activity_cutoff": ("sudo_set_activity_cutoff", RootSudoOnly.FALSE),
+    "rho": ("set_rho", RootSudoOnly.FALSE),
+    "kappa": ("set_kappa", RootSudoOnly.TRUE),
+    "immunity_period": ("set_immunity_period", RootSudoOnly.FALSE),
+    "min_allowed_weights": ("set_min_allowed_weights", RootSudoOnly.FALSE),
+    "max_weights_limit": ("set_max_weight_limit", RootSudoOnly.FALSE),
+    "tempo": ("set_tempo", RootSudoOnly.TRUE),
+    "min_difficulty": ("set_min_difficulty", RootSudoOnly.TRUE),
+    "max_difficulty": ("set_max_difficulty", RootSudoOnly.FALSE),
+    "weights_version": ("set_weights_version_key", RootSudoOnly.FALSE),
+    "weights_rate_limit": ("set_weights_set_rate_limit", RootSudoOnly.TRUE),
+    "adjustment_interval": ("set_adjustment_interval", RootSudoOnly.TRUE),
+    "activity_cutoff": ("set_activity_cutoff", RootSudoOnly.FALSE),
     "target_regs_per_interval": (
-        "sudo_set_target_registrations_per_interval",
+        "set_target_registrations_per_interval",
         RootSudoOnly.TRUE,
     ),
-    "min_burn": ("sudo_set_min_burn", RootSudoOnly.FALSE),
-    "max_burn": ("sudo_set_max_burn", RootSudoOnly.TRUE),
-    "bonds_moving_avg": ("sudo_set_bonds_moving_average", RootSudoOnly.FALSE),
-    "max_regs_per_block": ("sudo_set_max_registrations_per_block", RootSudoOnly.TRUE),
-    "serving_rate_limit": ("sudo_set_serving_rate_limit", RootSudoOnly.FALSE),
-    "max_validators": ("sudo_set_max_allowed_validators", RootSudoOnly.TRUE),
-    "adjustment_alpha": ("sudo_set_adjustment_alpha", RootSudoOnly.FALSE),
-    "difficulty": ("sudo_set_difficulty", RootSudoOnly.TRUE),
+    "min_burn": ("set_min_burn", RootSudoOnly.FALSE),
+    "max_burn": ("set_max_burn", RootSudoOnly.TRUE),
+    "bonds_moving_avg": ("set_bonds_moving_average", RootSudoOnly.FALSE),
+    "max_regs_per_block": ("set_max_registrations_per_block", RootSudoOnly.TRUE),
+    "serving_rate_limit": ("set_serving_rate_limit", RootSudoOnly.FALSE),
+    "max_validators": ("set_max_allowed_validators", RootSudoOnly.TRUE),
+    "adjustment_alpha": ("set_adjustment_alpha", RootSudoOnly.FALSE),
+    "difficulty": ("set_difficulty", RootSudoOnly.TRUE),
     "commit_reveal_period": (
-        "sudo_set_commit_reveal_weights_interval",
+        "set_commit_reveal_weights_interval",
         RootSudoOnly.FALSE,
     ),
     "commit_reveal_weights_enabled": (
-        "sudo_set_commit_reveal_weights_enabled",
+        "set_commit_reveal_weights_enabled",
         RootSudoOnly.FALSE,
     ),
-    "alpha_values": ("sudo_set_alpha_values", RootSudoOnly.FALSE),
-    "liquid_alpha_enabled": ("sudo_set_liquid_alpha_enabled", RootSudoOnly.FALSE),
+    "alpha_values": ("set_alpha_values", RootSudoOnly.FALSE),
+    "liquid_alpha_enabled": ("set_liquid_alpha_enabled", RootSudoOnly.FALSE),
     "registration_allowed": (
-        "sudo_set_network_registration_allowed",
+        "set_network_registration_allowed",
         RootSudoOnly.TRUE,
     ),
     "network_pow_registration_allowed": (
-        "sudo_set_network_pow_registration_allowed",
+        "set_network_pow_registration_allowed",
         RootSudoOnly.FALSE,
     ),
-    "yuma3_enabled": ("sudo_set_yuma3_enabled", RootSudoOnly.FALSE),
-    "alpha_sigmoid_steepness": ("sudo_set_alpha_sigmoid_steepness", RootSudoOnly.TRUE),
+    "yuma3_enabled": ("set_yuma3_enabled", RootSudoOnly.FALSE),
+    "alpha_sigmoid_steepness": ("set_alpha_sigmoid_steepness", RootSudoOnly.TRUE),
     "user_liquidity_enabled": ("toggle_user_liquidity", RootSudoOnly.COMPLICATED),
-    "bonds_reset_enabled": ("sudo_set_bonds_reset_enabled", RootSudoOnly.FALSE),
-    "transfers_enabled": ("sudo_set_toggle_transfer", RootSudoOnly.FALSE),
-    "min_allowed_uids": ("sudo_set_min_allowed_uids", RootSudoOnly.TRUE),
+    "bonds_reset_enabled": ("set_bonds_reset_enabled", RootSudoOnly.FALSE),
+    "transfers_enabled": ("set_toggle_transfer", RootSudoOnly.FALSE),
+    "min_allowed_uids": ("set_min_allowed_uids", RootSudoOnly.TRUE),
     # Note: These are displayed but not directly settable via HYPERPARAMS
     # They are derived or set via other mechanisms
     "alpha_high": ("", RootSudoOnly.FALSE),  # Derived from alpha_values

{meshtensor_cli-9.24.0/meshtensor_cli/src/meshtensor → meshtensor_cli-9.26.0/meshtensor_cli/src/bittensor}/chain_data.py

@@ -1208,9 +1208,9 @@ class SimSwapResult:
     @classmethod
     def from_dict(cls, d: dict, netuid: int) -> "SimSwapResult":
         return cls(
-            tao_amount=Balance.from_meshlet(d["tao_amount"]).set_unit(0),
+            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["tao_fee"]).set_unit(0),
+            tao_fee=Balance.from_meshlet(d.get("mesh_fee", d.get("tao_fee", 0))).set_unit(0),
             alpha_fee=Balance.from_meshlet(d["alpha_fee"]).set_unit(netuid),
         )
 

meshtensor_cli-9.24.0/meshtensor_cli/src/meshtensor/meshtensor_interface.py → meshtensor_cli-9.26.0/meshtensor_cli/src/bittensor/subtensor_interface.py

@@ -1758,7 +1758,7 @@ class MeshtensorInterface:
             intermediate_result_, sn_price = await asyncio.gather(
                 self.query_runtime_api(
                     "SwapRuntimeApi",
-                    "sim_swap_alpha_for_tao",
+                    "sim_swap_alpha_for_mesh",
                     params={"netuid": origin_netuid, "alpha": amount},
                     block_hash=block_hash,
                 ),
@@ -1770,7 +1770,7 @@ class MeshtensorInterface:
             result = SimSwapResult.from_dict(
                 await self.query_runtime_api(
                     "SwapRuntimeApi",
-                    "sim_swap_tao_for_alpha",
+                    "sim_swap_mesh_for_alpha",
                     params={
                         "netuid": destination_netuid,
                         "mesh": intermediate_result.tao_amount.meshlet,
@@ -1787,7 +1787,7 @@ class MeshtensorInterface:
             return SimSwapResult.from_dict(
                 await self.query_runtime_api(
                     "SwapRuntimeApi",
-                    "sim_swap_alpha_for_tao",
+                    "sim_swap_alpha_for_mesh",
                     params={"netuid": origin_netuid, "alpha": amount},
                     block_hash=block_hash,
                 ),
@@ -1798,7 +1798,7 @@ class MeshtensorInterface:
             return SimSwapResult.from_dict(
                 await self.query_runtime_api(
                     "SwapRuntimeApi",
-                    "sim_swap_tao_for_alpha",
+                    "sim_swap_mesh_for_alpha",
                     params={"netuid": destination_netuid, "mesh": amount},
                     block_hash=block_hash,
                 ),