meshtensor-cli 9.18.1__py3-none-any.whl

meshtensor_cli/src/commands/crowd/dissolve.py

@@ -0,0 +1,219 @@
+import asyncio
+import json
+from typing import Optional
+
+from meshtensor_wallet import Wallet
+from rich.table import Column, Table, box
+
+from meshtensor_cli.src import COLORS
+from meshtensor_cli.src.meshtensor.meshtensor_interface import MeshtensorInterface
+from meshtensor_cli.src.commands.crowd.view import show_crowdloan_details
+from meshtensor_cli.src.meshtensor.utils import (
+    blocks_to_duration,
+    confirm_action,
+    console,
+    json_console,
+    print_extrinsic_id,
+    print_error,
+    unlock_key,
+)
+
+
+async def dissolve_crowdloan(
+    meshtensor: MeshtensorInterface,
+    wallet: Wallet,
+    proxy: Optional[str],
+    crowdloan_id: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    prompt: bool = True,
+    decline: bool = False,
+    quiet: bool = False,
+    json_output: bool = False,
+) -> tuple[bool, str]:
+    """Dissolve a non-finalized crowdloan after refunding contributors.
+
+    The creator can reclaim their deposit once every other contribution has been
+    refunded (i.e., the raised amount equals the creator's contribution).
+
+    Args:
+        meshtensor: MeshtensorInterface object for chain interaction.
+        wallet: Wallet object containing the creator's coldkey.
+        proxy: Optional proxy to use for this extrinsic submission
+        crowdloan_id: ID of the crowdloan to dissolve.
+        wait_for_inclusion: Wait for transaction inclusion.
+        wait_for_finalization: Wait for transaction finalization.
+        prompt: Whether to prompt for confirmation.
+        json_output: Whether to output the results as JSON or human-readable.
+
+    Returns:
+        tuple[bool, str]: Success status and message.
+    """
+
+    creator_ss58 = wallet.coldkeypub.ss58_address
+
+    crowdloan, current_block = await asyncio.gather(
+        meshtensor.get_single_crowdloan(crowdloan_id),
+        meshtensor.substrate.get_block_number(None),
+    )
+
+    if not crowdloan:
+        error_msg = f"Crowdloan #{crowdloan_id} not found."
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(f"[red]{error_msg}[/red]")
+        return False, error_msg
+
+    if crowdloan.finalized:
+        error_msg = (
+            f"Crowdloan #{crowdloan_id} is already finalized and cannot be dissolved."
+        )
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(f"[red]{error_msg}[/red]")
+        return False, f"Crowdloan #{crowdloan_id} is finalized."
+
+    if creator_ss58 != crowdloan.creator:
+        error_msg = f"Only the creator can dissolve this crowdloan. Creator: {crowdloan.creator}, Your address: {creator_ss58}"
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(
+                f"[red]Only the creator can dissolve this crowdloan.[/red]\n"
+                f"Creator: [blue]{crowdloan.creator}[/blue]\n"
+                f"Your address: [blue]{creator_ss58}[/blue]"
+            )
+        return False, "Only the creator can dissolve this crowdloan."
+
+    creator_contribution = await meshtensor.get_crowdloan_contribution(
+        crowdloan_id, crowdloan.creator
+    )
+
+    if creator_contribution != crowdloan.raised:
+        error_msg = (
+            f"Crowdloan still holds funds from other contributors. "
+            f"Raised: {crowdloan.raised.tao}, Creator's contribution: {creator_contribution.tao}. "
+            "Run 'meshcli crowd refund' until only the creator's funds remain."
+        )
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(
+                f"[red]Crowdloan still holds funds from other contributors.[/red]\n"
+                f"Raised amount: [yellow]{crowdloan.raised}[/yellow]\n"
+                f"Creator's contribution: [yellow]{creator_contribution}[/yellow]\n"
+                "Run [cyan]meshcli crowd refund[/cyan] until only the creator's funds remain."
+            )
+        return False, "Crowdloan not ready to dissolve."
+
+    await show_crowdloan_details(
+        meshtensor=meshtensor,
+        crowdloan_id=crowdloan_id,
+        wallet=wallet,
+        verbose=False,
+        crowdloan=crowdloan,
+        current_block=current_block,
+    )
+
+    summary = Table(
+        Column("Field", style=COLORS.G.SUBHEAD),
+        Column("Value", style=COLORS.G.TEMPO),
+        box=box.SIMPLE,
+        show_header=False,
+    )
+    summary.add_row("Crowdloan ID", f"#{crowdloan_id}")
+    summary.add_row("Raised", str(crowdloan.raised))
+    summary.add_row("Creator Contribution", str(creator_contribution))
+    summary.add_row(
+        "Remaining Contributors",
+        str(max(0, crowdloan.contributors_count - 1)),
+    )
+    time_remaining = crowdloan.end - current_block
+    summary.add_row(
+        "Time Remaining",
+        blocks_to_duration(time_remaining) if time_remaining > 0 else "Ended",
+    )
+
+    console.print("\n[bold cyan]Crowdloan Dissolution Summary[/bold cyan]")
+    console.print(summary)
+
+    if prompt and not confirm_action(
+        f"\n[bold]Proceed with dissolving crowdloan #{crowdloan_id}?[/bold]",
+        default=False,
+        decline=decline,
+        quiet=quiet,
+    ):
+        if json_output:
+            json_console.print(
+                json.dumps(
+                    {"success": False, "error": "Dissolution cancelled by user."}
+                )
+            )
+        else:
+            console.print("[yellow]Dissolution cancelled.[/yellow]")
+        return False, "Dissolution cancelled by user."
+
+    unlock_status = unlock_key(wallet)
+    if not unlock_status.success:
+        if json_output:
+            json_console.print(
+                json.dumps({"success": False, "error": unlock_status.message})
+            )
+        else:
+            print_error(f"[red]{unlock_status.message}[/red]")
+        return False, unlock_status.message
+
+    with console.status(
+        ":satellite: Submitting dissolve transaction...", spinner="aesthetic"
+    ):
+        call = await meshtensor.substrate.compose_call(
+            call_module="Crowdloan",
+            call_function="dissolve",
+            call_params={"crowdloan_id": crowdloan_id},
+        )
+        (
+            success,
+            error_message,
+            extrinsic_receipt,
+        ) = await meshtensor.sign_and_send_extrinsic(
+            call=call,
+            wallet=wallet,
+            proxy=proxy,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
+    if not success:
+        if json_output:
+            json_console.print(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": error_message or "Failed to dissolve crowdloan.",
+                    }
+                )
+            )
+        else:
+            print_error(f"[red]Failed to dissolve crowdloan.[/red]\n{error_message}")
+        return False, error_message
+
+    if json_output:
+        extrinsic_id = await extrinsic_receipt.get_extrinsic_identifier()
+        output_dict = {
+            "success": True,
+            "error": None,
+            "extrinsic_identifier": extrinsic_id,
+            "data": {
+                "crowdloan_id": crowdloan_id,
+                "creator": crowdloan.creator,
+                "total_dissolved": creator_contribution.tao,
+            },
+        }
+        json_console.print(json.dumps(output_dict))
+    else:
+        await print_extrinsic_id(extrinsic_receipt)
+        console.print("[green]Crowdloan dissolved successfully![/green]")
+
+    return True, "Crowdloan dissolved successfully."

meshtensor_cli/src/commands/crowd/refund.py

@@ -0,0 +1,233 @@
+import asyncio
+import json
+from typing import Optional
+
+from meshtensor_wallet import Wallet
+from rich.table import Table, Column, box
+
+from meshtensor_cli.src import COLORS
+from meshtensor_cli.src.meshtensor.meshtensor_interface import MeshtensorInterface
+from meshtensor_cli.src.meshtensor.utils import (
+    confirm_action,
+    console,
+    json_console,
+    print_extrinsic_id,
+    print_error,
+    unlock_key,
+)
+from meshtensor_cli.src.commands.crowd.view import show_crowdloan_details
+from meshtensor_cli.src.commands.crowd.utils import get_constant
+
+
+async def refund_crowdloan(
+    meshtensor: MeshtensorInterface,
+    wallet: Wallet,
+    proxy: Optional[str],
+    crowdloan_id: int,
+    wait_for_inclusion: bool = True,
+    wait_for_finalization: bool = False,
+    prompt: bool = True,
+    decline: bool = False,
+    quiet: bool = False,
+    json_output: bool = False,
+) -> tuple[bool, str]:
+    """Refund contributors of a non-finalized crowdloan.
+
+    This extrinsic refunds all contributors (excluding the creator) up to the
+    RefundContributorsLimit. If there are more contributors than the limit,
+    this call may need to be executed multiple times until all contributors
+    are refunded.
+
+    Anyone can call this function - it does not need to be the creator.
+
+    Args:
+        meshtensor: MeshtensorInterface object for chain interaction
+        wallet: Wallet object containing coldkey (any wallet can call this)
+        proxy: Optional proxy to use for extrinsic submission
+        crowdloan_id: ID of the crowdloan to refund
+        wait_for_inclusion: Wait for transaction inclusion
+        wait_for_finalization: Wait for transaction finalization
+        prompt: Whether to prompt for confirmation
+        json_output: Whether to output as JSON or human-readable
+
+    Returns:
+        tuple[bool, str]: Success status and message
+    """
+    creator_ss58 = wallet.coldkeypub.ss58_address
+    crowdloan, current_block = await asyncio.gather(
+        meshtensor.get_single_crowdloan(crowdloan_id),
+        meshtensor.substrate.get_block_number(None),
+    )
+
+    if not crowdloan:
+        error_msg = f"Crowdloan #{crowdloan_id} not found."
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(f"[red]{error_msg}[/red]")
+        return False, error_msg
+
+    if crowdloan.finalized:
+        error_msg = f"Crowdloan #{crowdloan_id} is already finalized. Finalized crowdloans cannot be refunded."
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(f"[red]{error_msg}[/red]")
+        return False, f"Crowdloan #{crowdloan_id} is already finalized."
+
+    if creator_ss58 != crowdloan.creator:
+        error_msg = f"Only the creator can refund this crowdloan. Creator: {crowdloan.creator}, Your address: {creator_ss58}"
+        if json_output:
+            json_console.print(json.dumps({"success": False, "error": error_msg}))
+        else:
+            print_error(
+                f"[red]Only the creator can refund this crowdloan.[/red]\n"
+                f"Creator: [blue]{crowdloan.creator}[/blue]\n"
+                f"Your address: [blue]{creator_ss58}[/blue]"
+            )
+        return False, "Only the creator can refund this crowdloan."
+
+    await show_crowdloan_details(
+        meshtensor=meshtensor,
+        crowdloan_id=crowdloan_id,
+        wallet=wallet,
+        verbose=False,
+        crowdloan=crowdloan,
+        current_block=current_block,
+    )
+
+    refund_limit = await get_constant(meshtensor, "RefundContributorsLimit")
+
+    console.print("\n[bold cyan]Crowdloan Refund Information[/bold cyan]\n")
+
+    info_table = Table(
+        Column("[bold white]Property", style=COLORS.G.SUBHEAD),
+        Column("[bold white]Value", style=COLORS.G.TEMPO),
+        show_footer=False,
+        show_header=False,
+        width=None,
+        pad_edge=False,
+        box=box.SIMPLE,
+        show_edge=True,
+        border_style="bright_black",
+    )
+
+    info_table.add_row("Crowdloan ID", f"#{crowdloan_id}")
+    info_table.add_row("Total Contributors", f"{crowdloan.contributors_count:,}")
+    info_table.add_row("Refund Limit (per call)", f"{refund_limit:,} contributors")
+    info_table.add_row("Amount to Refund", crowdloan.raised - crowdloan.deposit)
+
+    if current_block >= crowdloan.end:
+        if crowdloan.raised < crowdloan.cap:
+            status = "[red]Failed[/red] (Cap not reached)"
+        else:
+            status = "[yellow]Ended but not finalized[/yellow]"
+    else:
+        status = "[green]Active[/green] (Still accepting contributions)"
+
+    info_table.add_row("Status", status)
+
+    refundable_contributors = max(0, crowdloan.contributors_count)
+    estimated_calls = (
+        (refundable_contributors + refund_limit) // refund_limit
+        if refund_limit > 0
+        else 0
+    )
+
+    if estimated_calls > 1:
+        info_table.add_row(
+            "Estimated Calls Needed",
+            f"[yellow]~{estimated_calls}[/yellow] (due to contributor limit)",
+        )
+
+    console.print(info_table)
+
+    if estimated_calls > 1:
+        console.print(
+            f"\n[yellow]Note:[/yellow] Due to the [cyan]Refund Contributors Limit[/cyan] of {refund_limit:,} contributors per call,\n"
+            f"  you may need to execute this command [yellow]{estimated_calls} times[/yellow] to refund all contributors.\n"
+            f"  Each call will refund up to {refund_limit:,} contributors until all are processed.\n"
+        )
+
+    if prompt and not confirm_action(
+        f"\n[bold]Proceed with refunding contributors of Crowdloan #{crowdloan_id}?[/bold]",
+        default=False,
+        decline=decline,
+        quiet=quiet,
+    ):
+        if json_output:
+            json_console.print(
+                json.dumps({"success": False, "error": "Refund cancelled by user."})
+            )
+        else:
+            console.print("[yellow]Refund cancelled.[/yellow]")
+        return False, "Refund cancelled by user."
+
+    unlock_status = unlock_key(wallet)
+    if not unlock_status.success:
+        if json_output:
+            json_console.print(
+                json.dumps({"success": False, "error": unlock_status.message})
+            )
+        else:
+            print_error(f"[red]{unlock_status.message}[/red]")
+        return False, unlock_status.message
+
+    with console.status(
+        ":satellite: Submitting refund transaction...", spinner="aesthetic"
+    ):
+        call = await meshtensor.substrate.compose_call(
+            call_module="Crowdloan",
+            call_function="refund",
+            call_params={
+                "crowdloan_id": crowdloan_id,
+            },
+        )
+        (
+            success,
+            error_message,
+            extrinsic_receipt,
+        ) = await meshtensor.sign_and_send_extrinsic(
+            call=call,
+            wallet=wallet,
+            proxy=proxy,
+            wait_for_inclusion=wait_for_inclusion,
+            wait_for_finalization=wait_for_finalization,
+        )
+
+    if not success:
+        if json_output:
+            json_console.print(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": error_message or "Failed to refund contributors.",
+                    }
+                )
+            )
+        else:
+            print_error(f"[red]Failed to refund contributors.[/red]\n{error_message}")
+        return False, error_message
+
+    if json_output:
+        extrinsic_id = await extrinsic_receipt.get_extrinsic_identifier()
+        output_dict = {
+            "success": True,
+            "error": None,
+            "extrinsic_identifier": extrinsic_id,
+            "data": {
+                "crowdloan_id": crowdloan_id,
+                "refund_limit_per_call": refund_limit,
+                "total_contributors": crowdloan.contributors_count,
+                "estimated_calls_remaining": max(0, estimated_calls - 1),
+                "amount_refunded": (crowdloan.raised - crowdloan.deposit).tao,
+            },
+        }
+        json_console.print(json.dumps(output_dict))
+    else:
+        console.print(
+            f"[green]Contributors have been refunded for Crowdloan #{crowdloan_id}.[/green]"
+        )
+        await print_extrinsic_id(extrinsic_receipt)
+
+    return True, f"Contributors have been refunded for Crowdloan #{crowdloan_id}."