meshtensor-cli 9.18.1__py3-none-any.whl

meshtensor_cli/src/meshtensor/extrinsics/serving.py

@@ -0,0 +1,255 @@
+"""
+Extrinsics for serving operations (axon management).
+"""
+
+import typing
+from typing import Optional
+
+from meshtensor_wallet import Wallet
+
+from meshtensor_cli.src.meshtensor.utils import (
+    confirm_action,
+    console,
+    print_error,
+    print_success,
+    format_error_message,
+    unlock_key,
+    print_extrinsic_id,
+)
+
+if typing.TYPE_CHECKING:
+    from meshtensor_cli.src.meshtensor.meshtensor_interface import MeshtensorInterface
+
+
+def ip_to_int(ip_str: str) -> int:
+    """
+    Converts an IP address string to its integer representation.
+
+    Args:
+        ip_str: IP address string (e.g., "192.168.1.1")
+
+    Returns:
+        Integer representation of the IP address
+    """
+    import netaddr
+
+    return int(netaddr.IPAddress(ip_str))
+
+
+async def reset_axon_extrinsic(
+    meshtensor: "MeshtensorInterface",
+    wallet: Wallet,
+    netuid: int,
+    prompt: bool = False,
+    decline: bool = False,
+    quiet: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str, Optional[str]]:
+    """
+    Resets the axon information for a neuron on the network.
+
+    This effectively removes the serving endpoint by setting the IP to 0.0.0.0
+    and port to 0, indicating the neuron is no longer serving.
+
+    Args:
+        meshtensor: The meshtensor interface to use for the extrinsic
+        wallet: The wallet containing the hotkey to reset the axon for
+        netuid: The network UID where the neuron is registered
+        prompt: Whether to prompt for confirmation before submitting
+        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block
+        wait_for_finalization: Whether to wait for the extrinsic to be finalized
+
+    Returns:
+        Tuple of (success: bool, message: str, extrinsic_id: Optional[str])
+    """
+    # Unlock the hotkey
+    if not (
+        unlock_status := unlock_key(wallet, unlock_type="hot", print_out=False)
+    ).success:
+        return False, unlock_status.message, None
+
+    # Prompt for confirmation if requested
+    if prompt:
+        if not confirm_action(
+            f"Do you want to reset the axon for hotkey [bold]{wallet.hotkey.ss58_address}[/bold] "
+            f"on netuid [bold]{netuid}[/bold]?",
+            decline=decline,
+            quiet=quiet,
+        ):
+            return False, "User cancelled the operation", None
+
+    with console.status(
+        f":satellite: Resetting axon on [white]netuid {netuid}[/white]..."
+    ):
+        try:
+            # Compose the serve_axon call with reset values (IP: 0.0.0.0, port: 1)
+            # Note: Port must be >= 1 as chain rejects port 0 as invalid
+            call = await meshtensor.substrate.compose_call(
+                call_module="MeshtensorModule",
+                call_function="serve_axon",
+                call_params={
+                    "netuid": netuid,
+                    "version": 0,
+                    "ip": ip_to_int("0.0.0.0"),
+                    "port": 1,
+                    "ip_type": 4,  # IPv4
+                    "protocol": 4,
+                    "placeholder1": 0,
+                    "placeholder2": 0,
+                },
+            )
+
+            # Sign with hotkey and submit the extrinsic
+            extrinsic = await meshtensor.substrate.create_signed_extrinsic(
+                call=call,
+                keypair=wallet.hotkey,
+            )
+            response = await meshtensor.substrate.submit_extrinsic(
+                extrinsic,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+            )
+
+            # We only wait here if we expect finalization.
+            if not wait_for_finalization and not wait_for_inclusion:
+                print_success(
+                    "[dark_sea_green3]Axon reset successfully[/dark_sea_green3]"
+                )
+                return True, "Not waiting for finalization or inclusion.", None
+
+            success = await response.is_success
+            if not success:
+                error_msg = format_error_message(await response.error_message)
+                print_error(f"Failed: {error_msg}")
+                return False, error_msg, None
+            else:
+                ext_id = await response.get_extrinsic_identifier()
+                await print_extrinsic_id(response)
+                print_success(
+                    "[dark_sea_green3]Axon reset successfully[/dark_sea_green3]"
+                )
+                return True, "Axon reset successfully", ext_id
+
+        except Exception as e:
+            error_message = format_error_message(e)
+            print_error(f"Failed to reset axon: {error_message}")
+            return False, error_message, None
+
+
+async def set_axon_extrinsic(
+    meshtensor: "MeshtensorInterface",
+    wallet: Wallet,
+    netuid: int,
+    ip: str,
+    port: int,
+    ip_type: int = 4,
+    protocol: int = 4,
+    prompt: bool = False,
+    decline: bool = False,
+    quiet: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+) -> tuple[bool, str, Optional[str]]:
+    """
+    Sets the axon information for a neuron on the network.
+
+    This configures the serving endpoint for a neuron by specifying its IP address
+    and port, allowing other neurons to connect to it.
+
+    Args:
+        meshtensor: The meshtensor interface to use for the extrinsic
+        wallet: The wallet containing the hotkey to set the axon for
+        netuid: The network UID where the neuron is registered
+        ip: The IP address to set (e.g., "192.168.1.1")
+        port: The port number to set
+        ip_type: IP type (4 for IPv4, 6 for IPv6)
+        protocol: Protocol version (default: 4)
+        prompt: Whether to prompt for confirmation before submitting
+        wait_for_inclusion: Whether to wait for the extrinsic to be included in a block
+        wait_for_finalization: Whether to wait for the extrinsic to be finalized
+
+    Returns:
+        Tuple of (success: bool, message: str, extrinsic_id: Optional[str])
+    """
+    # Validate port
+    if not (0 <= port <= 65535):
+        return False, f"Invalid port number: {port}. Must be between 0 and 65535.", None
+
+    # Validate IP address
+    try:
+        ip_int = ip_to_int(ip)
+    except Exception as e:
+        return False, f"Invalid IP address: {ip}. Error: {str(e)}", None
+
+    # Unlock the hotkey
+    if not (
+        unlock_status := unlock_key(wallet, unlock_type="hot", print_out=False)
+    ).success:
+        return False, unlock_status.message, None
+
+    # Prompt for confirmation if requested
+    if prompt:
+        if not confirm_action(
+            f"Do you want to set the axon for hotkey [bold]{wallet.hotkey.ss58_address}[/bold] "
+            f"on netuid [bold]{netuid}[/bold] to [bold]{ip}:{port}[/bold]?",
+            decline=decline,
+            quiet=quiet,
+        ):
+            return False, "User cancelled the operation", None
+
+    with console.status(
+        f":satellite: Setting axon on [white]netuid {netuid}[/white] to [white]{ip}:{port}[/white]..."
+    ):
+        try:
+            # Compose the serve_axon call
+            call = await meshtensor.substrate.compose_call(
+                call_module="MeshtensorModule",
+                call_function="serve_axon",
+                call_params={
+                    "netuid": netuid,
+                    "version": 0,
+                    "ip": ip_int,
+                    "port": port,
+                    "ip_type": ip_type,
+                    "protocol": protocol,
+                    "placeholder1": 0,
+                    "placeholder2": 0,
+                },
+            )
+
+            # Sign with hotkey and submit the extrinsic
+            extrinsic = await meshtensor.substrate.create_signed_extrinsic(
+                call=call,
+                keypair=wallet.hotkey,
+            )
+            response = await meshtensor.substrate.submit_extrinsic(
+                extrinsic,
+                wait_for_inclusion=wait_for_inclusion,
+                wait_for_finalization=wait_for_finalization,
+            )
+
+            # We only wait here if we expect finalization.
+            if not wait_for_finalization and not wait_for_inclusion:
+                print_success(
+                    f"[dark_sea_green3]Axon set successfully to {ip}:{port}[/dark_sea_green3]"
+                )
+                return True, "Not waiting for finalization or inclusion.", None
+
+            success = await response.is_success
+            if not success:
+                error_msg = format_error_message(await response.error_message)
+                print_error(f"Failed: {error_msg}")
+                return False, error_msg, None
+            else:
+                ext_id = await response.get_extrinsic_identifier()
+                await print_extrinsic_id(response)
+                print_success(
+                    f"[dark_sea_green3]Axon set successfully to {ip}:{port}[/dark_sea_green3]"
+                )
+                return True, f"Axon set successfully to {ip}:{port}", ext_id
+
+        except Exception as e:
+            error_message = format_error_message(e)
+            print_error(f"Failed to set axon: {error_message}")
+            return False, error_message, None

meshtensor_cli/src/meshtensor/extrinsics/transfer.py

@@ -0,0 +1,239 @@
+import asyncio
+from typing import Optional, Union
+
+from async_substrate_interface import AsyncExtrinsicReceipt
+from meshtensor_wallet import Wallet
+from meshtensor_cli.src.meshtensor.balances import Balance
+from meshtensor_cli.src.meshtensor.meshtensor_interface import (
+    MeshtensorInterface,
+    GENESIS_ADDRESS,
+)
+from meshtensor_cli.src.meshtensor.utils import (
+    confirm_action,
+    console,
+    print_error,
+    print_success,
+    print_verbose,
+    is_valid_meshtensor_address_or_public_key,
+    print_error,
+    unlock_key,
+)
+
+
+async def transfer_extrinsic(
+    meshtensor: MeshtensorInterface,
+    wallet: Wallet,
+    destination: str,
+    amount: Balance,
+    era: int = 3,
+    transfer_all: bool = False,
+    allow_death: bool = False,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    prompt: bool = False,
+    decline: bool = False,
+    quiet: bool = False,
+    proxy: Optional[str] = None,
+    announce_only: bool = False,
+) -> tuple[bool, Optional[AsyncExtrinsicReceipt]]:
+    """Transfers funds from this wallet to the destination public key address.
+
+    :param meshtensor: initialized MeshtensorInterface object used for transfer
+    :param wallet: Meshtensor wallet object to make transfer from.
+    :param destination: Destination public key address (ss58_address or ed25519) of recipient.
+    :param amount: Amount to stake as Meshtensor balance.
+    :param era: Length (in blocks) for which the transaction should be valid.
+    :param transfer_all: Whether to transfer all funds from this wallet to the destination address.
+    :param allow_death: Whether to allow for falling below the existential deposit when performing this transfer.
+    :param wait_for_inclusion: If set, waits for the extrinsic to enter a block before returning `True`,
+                               or returns `False` if the extrinsic fails to enter the block within the timeout.
+    :param wait_for_finalization:  If set, waits for the extrinsic to be finalized on the chain before returning
+                                   `True`, or returns `False` if the extrinsic fails to be finalized within the timeout.
+    :param prompt: If `True`, the call waits for confirmation from the user before proceeding.
+    :param proxy: Optional proxy to use for this call.
+    :param announce_only: If set along with proxy, will make this call as an announcement, rather than making the call
+
+    :return: success: Flag is `True` if extrinsic was finalized or included in the block. If we did not wait for
+                      finalization / inclusion, the response is `True`, regardless of its inclusion.
+    """
+
+    async def get_transfer_fee() -> Balance:
+        """
+        Calculates the transaction fee for transferring tokens from a wallet to a specified destination address.
+        This function simulates the transfer to estimate the associated cost, taking into account the current
+        network conditions and transaction complexity.
+        """
+        call = await meshtensor.substrate.compose_call(
+            call_module="Balances",
+            call_function=call_function,
+            call_params=call_params,
+        )
+        return await meshtensor.get_extrinsic_fee(
+            call=call, keypair=wallet.coldkeypub, proxy=proxy
+        )
+
+    async def do_transfer() -> tuple[bool, str, str, Optional[AsyncExtrinsicReceipt]]:
+        """
+        Makes transfer from wallet to destination public key address.
+        :return: success, block hash, formatted error message
+        """
+        call = await meshtensor.substrate.compose_call(
+            call_module="Balances",
+            call_function=call_function,
+            call_params=call_params,
+        )
+        success_, error_msg_, receipt_ = await meshtensor.sign_and_send_extrinsic(
+            call=call,
+            wallet=wallet,
+            wait_for_finalization=wait_for_finalization,
+            wait_for_inclusion=wait_for_inclusion,
+            proxy=proxy,
+            era={"period": era},
+            announce_only=announce_only,
+        )
+        block_hash_ = receipt_.block_hash if receipt_ is not None else ""
+        return success_, block_hash_, error_msg_, receipt_
+
+    # Validate destination address.
+    if not is_valid_meshtensor_address_or_public_key(destination):
+        print_error(
+            f"Invalid destination SS58 address:[bold white]\n  {destination}[/bold white]"
+        )
+        return False, None
+    console.print(f"[dark_orange]Initiating transfer on network: {meshtensor.network}")
+
+    call_params: dict[str, Optional[Union[str, int]]] = {"dest": destination}
+    if transfer_all:
+        call_function = "transfer_all"
+        if allow_death:
+            call_params["keep_alive"] = False
+        else:
+            call_params["keep_alive"] = True
+    else:
+        call_params["value"] = amount.meshlet
+        if allow_death:
+            call_function = "transfer_allow_death"
+        else:
+            call_function = "transfer_keep_alive"
+
+    # Check balance.
+    with console.status(
+        f":satellite: Checking balance and fees on chain [white]{meshtensor.network}[/white]",
+        spinner="aesthetic",
+    ) as status:
+        # check existential deposit and fee
+        print_verbose("Fetching existential and fee", status)
+        block_hash = await meshtensor.substrate.get_chain_head()
+        if proxy:
+            proxy_balance = await meshtensor.get_balance(proxy, block_hash=block_hash)
+        account_balance, existential_deposit, fee = await asyncio.gather(
+            meshtensor.get_balance(
+                wallet.coldkeypub.ss58_address, block_hash=block_hash
+            ),
+            meshtensor.get_existential_deposit(block_hash=block_hash),
+            get_transfer_fee(),
+        )
+
+    if allow_death:
+        # Check if the transfer should keep alive the account
+        existential_deposit = Balance(0)
+
+    if proxy:
+        if proxy_balance < (amount + existential_deposit) and not allow_death:
+            print_error(
+                "[bold red]Not enough balance[/bold red]:\n\n"
+                f"  balance: [bright_cyan]{proxy_balance}[/bright_cyan]\n"
+                f"  amount: [bright_cyan]{amount}[/bright_cyan]\n"
+                f"   would bring you under the existential deposit: [bright_cyan]{existential_deposit}[/bright_cyan].\n"
+                f"You can try again with `--allow-death`."
+            )
+            return False, None
+        if account_balance < fee:
+            print_error(
+                "[bold red]Not enough balance[/bold red]:\n\n"
+                f"  balance: [bright_cyan]{account_balance}[/bright_cyan]\n"
+                f"  fee: [bright_cyan]{fee}[/bright_cyan]\n"
+                f"   would bring you under the existential deposit: [bright_cyan]{existential_deposit}[/bright_cyan].\n"
+            )
+            return False, None
+        if account_balance < amount and allow_death:
+            print_error(
+                "[bold red]Not enough balance[/bold red]:\n\n"
+                f"  balance: [bright_red]{account_balance}[/bright_red]\n"
+                f"  amount: [bright_red]{amount}[/bright_red]\n"
+            )
+            return False, None
+    else:
+        if account_balance < (amount + fee + existential_deposit) and not allow_death:
+            print_error(
+                "[bold red]Not enough balance[/bold red]:\n\n"
+                f"  balance: [bright_cyan]{account_balance}[/bright_cyan]\n"
+                f"  amount: [bright_cyan]{amount}[/bright_cyan]\n"
+                f"  for fee: [bright_cyan]{fee}[/bright_cyan]\n"
+                f"   would bring you under the existential deposit: [bright_cyan]{existential_deposit}[/bright_cyan].\n"
+                f"You can try again with `--allow-death`."
+            )
+            return False, None
+        elif account_balance < (amount + fee) and allow_death:
+            print_error(
+                "[bold red]Not enough balance[/bold red]:\n\n"
+                f"  balance: [bright_red]{account_balance}[/bright_red]\n"
+                f"  amount: [bright_red]{amount}[/bright_red]\n"
+                f"  for fee: [bright_red]{fee}[/bright_red]"
+            )
+            return False, None
+    if proxy:
+        account_balance = proxy_balance
+
+    # Ask before moving on.
+    if prompt:
+        hk_owner = await meshtensor.get_hotkey_owner(destination, check_exists=False)
+        if hk_owner and hk_owner not in (destination, GENESIS_ADDRESS):
+            if not confirm_action(
+                f"The destination appears to be a hotkey, owned by [bright_magenta]{hk_owner}[/bright_magenta]. "
+                f"Only proceed if you are absolutely sure that [bright_magenta]{destination}[/bright_magenta] is the "
+                f"correct destination.",
+                default=False,
+                decline=decline,
+                quiet=quiet,
+            ):
+                return False, None
+        if not confirm_action(
+            "Do you want to transfer:[bold white]\n"
+            f"  amount: [bright_cyan]{amount if not transfer_all else account_balance}[/bright_cyan]\n"
+            f"  from: [light_goldenrod2]{wallet.name}[/light_goldenrod2] : "
+            f"[bright_magenta]{wallet.coldkeypub.ss58_address}\n[/bright_magenta]"
+            f"  to: [bright_magenta]{destination}[/bright_magenta]\n  for fee: [bright_cyan]{fee}[/bright_cyan]\n"
+            f"[bright_yellow]Transferring is not the same as staking. To instead stake, use "
+            f"[dark_orange]meshcli stake add[/dark_orange] instead[/bright_yellow].\n"
+            f"Proceed with transfer?",
+            decline=decline,
+            quiet=quiet,
+        ):
+            return False, None
+
+    # Unlock wallet coldkey.
+    if not unlock_key(wallet).success:
+        return False, None
+
+    with console.status(":satellite: Transferring...", spinner="earth"):
+        success, block_hash, err_msg, ext_receipt = await do_transfer()
+
+        if success:
+            print_success(f"Finalized. Block Hash: {block_hash}")
+
+        else:
+            print_error(f"Failed: {err_msg}")
+
+    if success:
+        with console.status(":satellite: Checking Balance...", spinner="aesthetic"):
+            new_balance = await meshtensor.get_balance(
+                proxy or wallet.coldkeypub.ss58_address, reuse_block=False
+            )
+            console.print(
+                f"Balance:\n"
+                f"  [blue]{account_balance}[/blue] :arrow_right: [green]{new_balance}[/green]"
+            )
+            return True, ext_receipt
+
+    return False, None