chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/cmds/farm.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from chia.cmds.cmd_classes import ChiaCliContext
+
+
+@click.group("farm", help="Manage your farm")
+def farm_cmd() -> None:
+    pass
+
+
+@farm_cmd.command("summary", help="Summary of farming information")
+@click.option(
+    "-p",
+    "--rpc-port",
+    help=(
+        "Set the port where the Full Node is hosting the RPC interface. "
+        "See the rpc_port under full_node in config.yaml"
+    ),
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "-wp",
+    "--wallet-rpc-port",
+    help="Set the port where the Wallet is hosting the RPC interface. See the rpc_port under wallet in config.yaml",
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "-hp",
+    "--harvester-rpc-port",
+    help=(
+        "Set the port where the Harvester is hosting the RPC interface"
+        "See the rpc_port under harvester in config.yaml"
+    ),
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "-fp",
+    "--farmer-rpc-port",
+    help=("Set the port where the Farmer is hosting the RPC interface. See the rpc_port under farmer in config.yaml"),
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.pass_context
+def summary_cmd(
+    ctx: click.Context,
+    rpc_port: Optional[int],
+    wallet_rpc_port: Optional[int],
+    harvester_rpc_port: Optional[int],
+    farmer_rpc_port: Optional[int],
+) -> None:
+    import asyncio
+
+    from chia.cmds.farm_funcs import summary
+
+    asyncio.run(
+        summary(
+            rpc_port,
+            wallet_rpc_port,
+            harvester_rpc_port,
+            farmer_rpc_port,
+            root_path=ChiaCliContext.set_default(ctx).root_path,
+        )
+    )
+
+
+@farm_cmd.command("challenges", help="Show the latest challenges")
+@click.option(
+    "-fp",
+    "--farmer-rpc-port",
+    help="Set the port where the Farmer is hosting the RPC interface. See the rpc_port under farmer in config.yaml",
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "-l",
+    "--limit",
+    help="Limit the number of challenges shown. Use 0 to disable the limit",
+    type=click.IntRange(0),
+    default=20,
+    show_default=True,
+)
+@click.pass_context
+def challenges_cmd(ctx: click.Context, farmer_rpc_port: Optional[int], limit: int) -> None:
+    import asyncio
+
+    from chia.cmds.farm_funcs import challenges
+
+    asyncio.run(challenges(ChiaCliContext.set_default(ctx).root_path, farmer_rpc_port, limit))

chia/cmds/farm_funcs.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import sys
+import traceback
+from pathlib import Path
+from typing import Any, Optional
+
+from chia.cmds.cmds_util import format_bytes, format_minutes, get_any_service_client
+from chia.cmds.units import units
+from chia.consensus.block_record import BlockRecord
+from chia.rpc.farmer_rpc_client import FarmerRpcClient
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.util.errors import CliRpcConnectionError
+from chia.util.network import is_localhost
+
+SECONDS_PER_BLOCK = (24 * 3600) / 4608
+
+
+async def get_harvesters_summary(farmer_rpc_port: Optional[int], root_path: Path) -> Optional[dict[str, Any]]:
+    async with get_any_service_client(FarmerRpcClient, root_path, farmer_rpc_port) as (farmer_client, _):
+        return await farmer_client.get_harvesters_summary()
+
+
+async def get_blockchain_state(rpc_port: Optional[int], root_path: Path) -> Optional[dict[str, Any]]:
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (client, _):
+        return await client.get_blockchain_state()
+
+
+async def get_average_block_time(rpc_port: Optional[int], root_path: Path) -> float:
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (client, _):
+        blocks_to_compare = 500
+        blockchain_state = await client.get_blockchain_state()
+        curr: Optional[BlockRecord] = blockchain_state["peak"]
+        if curr is None or curr.height < (blocks_to_compare + 100):
+            return SECONDS_PER_BLOCK
+        while curr is not None and curr.height > 0 and not curr.is_transaction_block:
+            curr = await client.get_block_record(curr.prev_hash)
+        if curr is None or curr.timestamp is None or curr.height is None:
+            # stupid mypy
+            return SECONDS_PER_BLOCK
+        past_curr = await client.get_block_record_by_height(curr.height - blocks_to_compare)
+        while past_curr is not None and past_curr.height > 0 and not past_curr.is_transaction_block:
+            past_curr = await client.get_block_record(past_curr.prev_hash)
+        if past_curr is None or past_curr.timestamp is None or past_curr.height is None:
+            # stupid mypy
+            return SECONDS_PER_BLOCK
+        return (curr.timestamp - past_curr.timestamp) / (curr.height - past_curr.height)
+
+
+async def get_wallets_stats(wallet_rpc_port: Optional[int], root_path: Path) -> Optional[dict[str, Any]]:
+    async with get_any_service_client(WalletRpcClient, root_path, wallet_rpc_port) as (wallet_client, _):
+        return await wallet_client.get_farmed_amount()
+
+
+async def get_challenges(root_path: Path, farmer_rpc_port: Optional[int]) -> Optional[list[dict[str, Any]]]:
+    async with get_any_service_client(FarmerRpcClient, root_path, farmer_rpc_port) as (farmer_client, _):
+        return await farmer_client.get_signage_points()
+
+
+async def challenges(root_path: Path, farmer_rpc_port: Optional[int], limit: int) -> None:
+    signage_points = await get_challenges(root_path, farmer_rpc_port)
+    if signage_points is None:
+        return None
+
+    signage_points.reverse()
+    if limit != 0:
+        signage_points = signage_points[:limit]
+
+    for signage_point in signage_points:
+        print(
+            f"Hash: {signage_point['signage_point']['challenge_hash']} "
+            f"Index: {signage_point['signage_point']['signage_point_index']}"
+        )
+
+
+async def summary(
+    rpc_port: Optional[int],
+    wallet_rpc_port: Optional[int],
+    harvester_rpc_port: Optional[int],
+    farmer_rpc_port: Optional[int],
+    root_path: Path,
+) -> None:
+    harvesters_summary = await get_harvesters_summary(farmer_rpc_port, root_path)
+    blockchain_state = None
+    try:
+        blockchain_state = await get_blockchain_state(rpc_port, root_path)
+    except CliRpcConnectionError:
+        pass
+    except Exception:
+        print("Error while trying to get blockchain state!", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+
+    farmer_running = False if harvesters_summary is None else True  # harvesters uses farmer rpc too
+
+    wallet_not_ready: bool = False
+    amounts = None
+    try:
+        amounts = await get_wallets_stats(wallet_rpc_port, root_path)
+    except CliRpcConnectionError:
+        wallet_not_ready = True
+    except Exception:
+        print("Error while trying to get wallet stats!", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+    wallet_not_running: bool = True if amounts is None else False
+
+    print("Farming status: ", end="")
+    if blockchain_state is None:
+        print("Not available")
+    elif blockchain_state["sync"]["sync_mode"]:
+        print("Syncing")
+    elif not blockchain_state["sync"]["synced"]:
+        print("Not synced or not connected to peers")
+    elif not farmer_running:
+        print("Not running")
+    else:
+        print("Farming")
+
+    if amounts is not None:
+        print(f"Total chia farmed: {amounts['farmed_amount'] / units['chia']}")
+        print(f"User transaction fees: {amounts['fee_amount'] / units['chia']}")
+        print(f"Block rewards: {(amounts['farmer_reward_amount'] + amounts['pool_reward_amount']) / units['chia']}")
+        print(f"Last height farmed: {amounts['last_height_farmed']}")
+
+    class PlotStats:
+        total_plot_size = 0
+        total_effective_plot_size = 0
+        total_plots = 0
+
+    if harvesters_summary is not None:
+        harvesters_local: dict[str, dict[str, Any]] = {}
+        harvesters_remote: dict[str, dict[str, Any]] = {}
+        for harvester in harvesters_summary["harvesters"]:
+            ip = harvester["connection"]["host"]
+            if is_localhost(ip):
+                harvesters_local[harvester["connection"]["node_id"]] = harvester
+            else:
+                if ip not in harvesters_remote:
+                    harvesters_remote[ip] = {}
+                harvesters_remote[ip][harvester["connection"]["node_id"]] = harvester
+
+        def process_harvesters(harvester_peers_in: dict[str, dict[str, Any]]) -> None:
+            for harvester_peer_id, harvester_dict in harvester_peers_in.items():
+                syncing = harvester_dict["syncing"]
+                if syncing is not None and syncing["initial"]:
+                    print(f"   Loading plots: {syncing['plot_files_processed']} / {syncing['plot_files_total']}")
+                else:
+                    total_plot_size_harvester = harvester_dict["total_plot_size"]
+                    total_effective_plot_size_harvester = harvester_dict["total_effective_plot_size"]
+                    plot_count_harvester = harvester_dict["plots"]
+                    PlotStats.total_plot_size += total_plot_size_harvester
+                    PlotStats.total_effective_plot_size += total_effective_plot_size_harvester
+                    PlotStats.total_plots += plot_count_harvester
+                    print(
+                        f"   {plot_count_harvester} plots of size: {format_bytes(total_plot_size_harvester)} on-disk, "
+                        f"{format_bytes(total_effective_plot_size_harvester)}e (effective)"
+                    )
+
+        if len(harvesters_local) > 0:
+            print(f"Local Harvester{'s' if len(harvesters_local) > 1 else ''}")
+            process_harvesters(harvesters_local)
+        for harvester_ip, harvester_peers in harvesters_remote.items():
+            print(f"Remote Harvester{'s' if len(harvester_peers) > 1 else ''} for IP: {harvester_ip}")
+            process_harvesters(harvester_peers)
+
+        print(f"Plot count for all harvesters: {PlotStats.total_plots}")
+
+        print(
+            f"Total size of plots: {format_bytes(PlotStats.total_plot_size)}, "
+            f"{format_bytes(PlotStats.total_effective_plot_size)}e (effective)"
+        )
+    else:
+        print("Plot count: Unknown")
+        print("Total size of plots: Unknown")
+
+    if blockchain_state is not None:
+        print("Estimated network space: ", end="")
+        print(format_bytes(blockchain_state["space"]))
+    else:
+        print("Estimated network space: Unknown")
+
+    minutes = -1
+    if blockchain_state is not None and harvesters_summary is not None:
+        proportion = (
+            PlotStats.total_effective_plot_size / blockchain_state["space"] if blockchain_state["space"] else -1
+        )
+        minutes = int((await get_average_block_time(rpc_port, root_path) / 60) / proportion) if proportion else -1
+
+    if harvesters_summary is not None and PlotStats.total_plots == 0:
+        print("Expected time to win: Never (no plots)")
+    else:
+        print("Expected time to win: " + format_minutes(minutes))
+
+    if amounts is None:
+        if wallet_not_running:
+            print("For details on farmed rewards and fees you should run 'chia start wallet' and 'chia wallet show'")
+        elif wallet_not_ready:
+            print("For details on farmed rewards and fees you should run 'chia wallet show'")
+    else:
+        print("Note: log into your key using 'chia wallet show' to see rewards for each key")

chia/cmds/gh.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import urllib
+import uuid
+import webbrowser
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Callable, ClassVar, Literal, Optional, Union, overload
+
+import anyio
+import click
+import yaml
+
+from chia.cmds.cmd_classes import chia_command, option
+
+
+class UnexpectedFormError(Exception):
+    pass
+
+
+Oses = Union[Literal["linux"], Literal["macos-arm"], Literal["macos-intel"], Literal["windows"]]
+Method = Union[Literal["GET"], Literal["POST"]]
+Per = Union[Literal["directory"], Literal["file"]]
+
+all_oses: Sequence[Oses] = ("linux", "macos-arm", "macos-intel", "windows")
+
+
+def report(*args: str) -> None:
+    print("    ====", *args)
+
+
+async def get_gh_token() -> str:
+    command = ["gh", "auth", "token"]
+    report(f"running command: {shlex.join(command)}")
+    process = await anyio.run_process(command=command, check=False, stderr=None)
+
+    if process.returncode != 0:
+        raise click.ClickException("failed to get gh cli personal access token")
+
+    return process.stdout.decode("utf-8").strip()
+
+
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str) -> None: ...
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: Literal[False]) -> None: ...
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: Literal[True]) -> str: ...
+
+
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: bool = False) -> Optional[str]:
+    command = [
+        "gh",
+        "api",
+        f"--method={method}",
+        "-H=Accept: application/vnd.github+json",
+        "-H=X-GitHub-Api-Version: 2022-11-28",
+        *args,
+    ]
+    report(f"running command: {shlex.join(command)}")
+
+    if capture_stdout:
+        process = await anyio.run_process(command=command, check=False, stderr=None)
+    else:
+        process = await anyio.run_process(command=command, check=False, stderr=None, stdout=None)
+
+    if process.returncode != 0:
+        raise click.ClickException(error)
+
+    if capture_stdout:
+        return process.stdout.decode("utf-8")
+
+    return None
+
+
+def input_arg(name: str, value: object, cond: bool = True) -> list[str]:
+    if not cond:
+        return []
+
+    assert value is not None
+
+    if isinstance(value, os.PathLike):
+        value = os.fspath(value)
+    dumped = yaml.safe_dump(value).partition("\n")[0]
+    return [f"-f=inputs[{name}]={dumped}"]
+
+
+@click.group("gh", help="For working with GitHub")
+def gh_group() -> None:
+    pass
+
+
+@chia_command(
+    group=gh_group,
+    name="test",
+    short_help="launch a test run in CI from HEAD or existing remote ref",
+    help="""Allows easy triggering and viewing of test workflow runs in CI including
+    configuration of parameters.  If a ref is specified then it must exist on the
+    remote and a run will be launched for it.  If ref is not specified then the local
+    HEAD will be pushed to a temporary remote branch and a run will be launched for
+    that.  There is no need to push the local commit first.  The temporary remote
+    branch will automatically be deleted in most cases.
+
+    After launching the workflow run GitHub will be queried for the run and the URL
+    will be opened in the default browser.
+    """,
+)
+class TestCMD:
+    workflow_id: ClassVar[str] = "test.yml"
+    owner: str = option("-o", "--owner", help="Owner of the repo", type=str, default="Chia-Network")
+    repository: str = option("-r", "--repository", help="Repository name", type=str, default="chia-blockchain")
+    ref: Optional[str] = option(
+        "-f",
+        "--ref",
+        help="Branch or tag name (commit SHA not supported), if not specified will push HEAD to a temporary branch",
+        type=str,
+        default=None,
+    )
+    per: Per = option("-p", "--per", help="Per", type=click.Choice(["directory", "file"]), default="directory")
+    only: Optional[Path] = option(
+        "-o", "--only", help="Only run this item, a file or directory depending on --per", type=Path
+    )
+    duplicates: int = option("-d", "--duplicates", help="Number of duplicates", type=int, default=1)
+    oses: Sequence[Oses] = option(
+        "--os",
+        help="Operating systems to run on",
+        type=click.Choice(all_oses),
+        multiple=True,
+        default=all_oses,
+    )
+    full_python_matrix: bool = option(
+        "--full-python-matrix/--default-python-matrix", help="Run on all Python versions", default=False
+    )
+    remote: str = option("-r", "--remote", help="Name of git remote", type=str, default="origin")
+    open_browser: bool = option("--open-browser/--no-open-browser", help="Open browser", default=True)
+
+    async def run(self) -> None:
+        await self.check_only()
+
+        username = await self.get_username()
+
+        if self.ref is not None:
+            await self.trigger_workflow(self.ref)
+            query = "+".join(
+                [
+                    "event=workflow_dispatch",
+                    f"branch={self.ref}",
+                    f"actor={username}",
+                ]
+            )
+            run_url = f"https://github.com/Chia-Network/chia-blockchain/actions/workflows/test.yml?query={urllib.parse.quote(query)}"
+            report(f"waiting a few seconds to load: {run_url}")
+            await anyio.sleep(10)
+        else:
+            process = await anyio.run_process(command=["git", "rev-parse", "HEAD"], check=True, stderr=None)
+            if process.returncode != 0:
+                raise click.ClickException("Failed to get current commit SHA")
+
+            commit_sha = process.stdout.decode("utf-8").strip()
+
+            temp_branch_name = f"tmp/{username}/{commit_sha}/{uuid.uuid4()}"
+
+            process = await anyio.run_process(
+                command=["git", "push", self.remote, f"HEAD:{temp_branch_name}"], check=False, stdout=None, stderr=None
+            )
+            if process.returncode != 0:
+                raise click.ClickException("Failed to push temporary branch")
+
+            try:
+                await self.trigger_workflow(temp_branch_name)
+                for _ in range(10):
+                    await anyio.sleep(1)
+
+                    try:
+                        report("looking for run")
+                        html_url, api_url = await self.find_run(temp_branch_name)
+                        report(f"run found at: {html_url}")
+                        report(f"run found at: {api_url}")
+                    except UnexpectedFormError:
+                        report("run not found")
+                        continue
+
+                    break
+                else:
+                    raise click.ClickException("Failed to find run url")
+            finally:
+                report(f"deleting temporary branch: {temp_branch_name}")
+                process = await anyio.run_process(
+                    command=["git", "push", self.remote, "-d", temp_branch_name], check=False, stdout=None, stderr=None
+                )
+                if process.returncode != 0:
+                    raise click.ClickException("Failed to dispatch workflow")
+                report(f"temporary branch deleted: {temp_branch_name}")
+
+        report(f"run html url: {html_url}")
+        report(f"run api url: {api_url}")
+        if self.open_browser:
+            webbrowser.open(html_url)
+
+    async def check_only(self) -> None:
+        if self.only is not None:
+            import chia._tests
+
+            test_path = Path(chia._tests.__file__).parent
+            effective_path = test_path.joinpath(self.only)
+            checks: dict[Per, Callable[[], bool]] = {"directory": effective_path.is_dir, "file": effective_path.is_file}
+            check = checks[self.per]
+            if not check():
+                if effective_path.exists():
+                    explanation = "wrong type"
+                else:
+                    explanation = "does not exist"
+                message = f"expected requested --only to be a {self.per}, {explanation} at: {effective_path.as_posix()}"
+                raise click.ClickException(message)
+
+    async def trigger_workflow(self, ref: str) -> None:
+        # https://docs.github.com/en/rest/actions/workflows?apiVersion=2022-11-28#create-a-workflow-dispatch-event
+        await run_gh_api(
+            method="POST",
+            args=[
+                f"/repos/{self.owner}/{self.repository}/actions/workflows/{self.workflow_id}/dispatches",
+                f"-f=ref={ref}",
+                *input_arg("per", self.per),
+                *input_arg("only", self.only, self.only is not None),
+                *input_arg("duplicates", self.duplicates),
+                *(arg for os_name in all_oses for arg in input_arg(f"run-{os_name}", os_name in self.oses)),
+                *input_arg("full-python-matrix", self.full_python_matrix),
+            ],
+            error="Failed to dispatch workflow",
+        )
+        report(f"workflow triggered on branch: {ref}")
+
+    async def find_run(self, ref: str) -> tuple[str, str]:
+        # https://docs.github.com/en/rest/actions/workflow-runs?apiVersion=2022-11-28#list-workflow-runs-for-a-workflow
+        stdout = await run_gh_api(
+            method="GET",
+            args=[
+                f"-f=branch={ref}",
+                f"/repos/{self.owner}/{self.repository}/actions/workflows/{self.workflow_id}/runs",
+            ],
+            error="Failed to query workflow runs",
+            capture_stdout=True,
+        )
+
+        response = json.loads(stdout)
+        runs = response["workflow_runs"]
+        try:
+            [run] = runs
+        except ValueError:
+            raise UnexpectedFormError(f"expected 1 run, got: {len(runs)}")
+
+        html_url = run["html_url"]
+        assert isinstance(html_url, str), f"expected html url to be a string, got: {html_url!r}"
+
+        api_url = run["url"]
+        assert isinstance(api_url, str), f"expected url to be a string, got: {api_url!r}"
+
+        return html_url, api_url
+
+    async def get_username(self) -> str:
+        # https://docs.github.com/en/rest/users/users?apiVersion=2022-11-28#get-the-authenticated-user
+        stdout = await run_gh_api(
+            method="GET",
+            args=["/user"],
+            error="Failed to get username",
+            capture_stdout=True,
+        )
+
+        response = json.loads(stdout)
+        username = response["login"]
+        assert isinstance(username, str), f"expected username to be a string, got: {username!r}"
+        return username

chia/cmds/init.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import click
+
+from chia.cmds.cmd_classes import ChiaCliContext
+
+
+@click.command("init", help="Create or migrate the configuration")
+@click.option(
+    "--create-certs",
+    "-c",
+    default=None,
+    help="Create new SSL certificates based on CA in [directory]",
+    type=click.Path(),
+)
+@click.option(
+    "--fix-ssl-permissions",
+    is_flag=True,
+    help="Attempt to fix SSL certificate/key file permissions",
+)
+@click.option("--testnet", is_flag=True, help="Configure this chia install to connect to the testnet")
+@click.option("--set-passphrase", "-s", is_flag=True, help="Protect your keyring with a passphrase")
+@click.option(
+    "--v1-db",
+    is_flag=True,
+    help="Initialize the blockchain database in v1 format (compatible with older versions of the full node)",
+)
+@click.pass_context
+def init_cmd(
+    ctx: click.Context,
+    create_certs: str,
+    fix_ssl_permissions: bool,
+    testnet: bool,
+    set_passphrase: bool,
+    v1_db: bool,
+) -> None:
+    """
+    Create a new configuration or migrate from previous versions to current
+
+    \b
+    Follow these steps to create new certificates for a remote harvester:
+    - Make a copy of your Farming Machine CA directory: ~/.chia/[version]/config/ssl/ca
+    - Shut down all chia daemon processes with `chia stop all -d`
+    - Run `chia init -c [directory]` on your remote harvester,
+      where [directory] is the copy of your Farming Machine CA directory
+    - Get more details on remote harvester on Chia wiki:
+      https://github.com/Chia-Network/chia-blockchain/wiki/Farming-on-many-machines
+    """
+    from pathlib import Path
+
+    from chia.cmds.init_funcs import init
+    from chia.cmds.passphrase_funcs import initialize_passphrase
+
+    if set_passphrase:
+        initialize_passphrase()
+
+    init(
+        Path(create_certs) if create_certs is not None else None,
+        ChiaCliContext.set_default(ctx).root_path,
+        fix_ssl_permissions,
+        testnet,
+        v1_db,
+    )