chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/cmds/cmd_classes.py

@@ -25,7 +25,7 @@ from chia_rs.sized_bytes import bytes32
 from typing_extensions import dataclass_transform
 
 from chia.util.byte_types import hexstr_to_bytes
-from chia.util.default_root import DEFAULT_ROOT_PATH
+from chia.util.default_root import DEFAULT_KEYS_ROOT_PATH, DEFAULT_ROOT_PATH
 from chia.util.streamable import is_type_SpecificOptional
 
 SyncCmd = Callable[..., None]
@@ -45,11 +45,11 @@ ChiaCommand = Union[SyncChiaCommand, AsyncChiaCommand]
 
 
 def option(*param_decls: str, **kwargs: Any) -> Any:
-    if sys.version_info < (3, 10):  # versions < 3.10 don't know about kw_only and they complain about lacks of defaults
+    if sys.version_info >= (3, 10):
+        default_default = MISSING
+    else:  # versions < 3.10 don't know about kw_only and they complain about lacks of defaults
         # Can't get coverage on this because we only test on one version
         default_default = None  # pragma: no cover
-    else:
-        default_default = MISSING
 
     return field(
         metadata=dict(
@@ -68,6 +68,7 @@ class ChiaCliContext:
     context_dict_key: ClassVar[str] = "_chia_cli_context"
 
     root_path: pathlib.Path = DEFAULT_ROOT_PATH
+    keys_root_path: pathlib.Path = DEFAULT_KEYS_ROOT_PATH
     expected_prefix: Optional[str] = None
     rpc_port: Optional[int] = None
     keys_fingerprint: Optional[int] = None
@@ -269,15 +270,15 @@ def chia_command(
     def _chia_command(cls: type[ChiaCommand]) -> type[ChiaCommand]:
         # The type ignores here are largely due to the fact that the class information is not preserved after being
         # passed through the dataclass wrapper.  Not sure what to do about this right now.
-        if sys.version_info < (3, 10):  # pragma: no cover
-            # stuff below 3.10 doesn't know about kw_only
+        if sys.version_info >= (3, 10):
             wrapped_cls: type[ChiaCommand] = dataclass(
                 frozen=True,
+                kw_only=True,
             )(cls)
-        else:
+        else:  # pragma: no cover
+            # stuff below 3.10 doesn't know about kw_only
             wrapped_cls: type[ChiaCommand] = dataclass(
                 frozen=True,
-                kw_only=True,
             )(cls)
 
         metadata = Metadata(
@@ -315,9 +316,9 @@ def get_chia_command_metadata(cls: type[ChiaCommand]) -> Metadata:
 
 @dataclass_transform(frozen_default=True)
 def command_helper(cls: type[Any]) -> type[Any]:
-    if sys.version_info < (3, 10):  # stuff below 3.10 doesn't support kw_only
-        new_cls = dataclass(frozen=True)(cls)  # pragma: no cover
-    else:
+    if sys.version_info >= (3, 10):
         new_cls = dataclass(frozen=True, kw_only=True)(cls)
+    else:  # stuff below 3.10 doesn't support kw_only
+        new_cls = dataclass(frozen=True)(cls)  # pragma: no cover
     setattr(new_cls, COMMAND_HELPER_ATTRIBUTE_NAME, True)
     return new_cls

chia/cmds/cmd_helpers.py

@@ -13,10 +13,10 @@ from chia_rs.sized_ints import uint64
 from chia.cmds.cmd_classes import ChiaCliContext, command_helper, option
 from chia.cmds.cmds_util import CMDCoinSelectionConfigLoader, CMDTXConfigLoader, TransactionBundle, get_wallet_client
 from chia.cmds.param_types import AmountParamType, Bytes32ParamType, CliAmount, TransactionFeeParamType, cli_amount_none
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 
 @dataclass(frozen=True)

chia/cmds/cmds_util.py

@@ -17,13 +17,11 @@ from chia_rs.sized_ints import uint16, uint32, uint64
 from chia.cmds.param_types import AmountParamType, Bytes32ParamType, CliAmount, cli_amount_none
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_validate
-from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
-from chia.rpc.harvester_rpc_client import HarvesterRpcClient
+from chia.data_layer.data_layer_rpc_client import DataLayerRpcClient
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.harvester.harvester_rpc_client import HarvesterRpcClient
 from chia.rpc.rpc_client import ResponseFailureError, RpcClient
-from chia.rpc.wallet_request_types import LogIn
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcClient
 from chia.types.mempool_submission_status import MempoolSubmissionStatus
 from chia.util.config import load_config
@@ -33,6 +31,8 @@ from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import CoinSelectionConfig, CoinSelectionConfigLoader, TXConfig, TXConfigLoader
+from chia.wallet.wallet_request_types import LogIn
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 NODE_TYPES: dict[str, type[RpcClient]] = {
     "base": RpcClient,
@@ -141,9 +141,12 @@ async def get_any_service_client(
 
             if tb is not None:
                 print(f"Traceback:\n{tb}")
+        except (click.ClickException, click.Abort):
+            # this includes CliRpcConnectionError which is a subclass of click.ClickException
+            # raising here allows click to do it's normal click error handling
+            raise
         except Exception as e:  # this is only here to make the errors more user-friendly.
-            if not consume_errors or isinstance(e, (CliRpcConnectionError, click.Abort)):
-                # CliRpcConnectionError will be handled by click.
+            if not consume_errors:
                 raise
             print(f"Exception from '{node_type}' {e}:\n{traceback.format_exc()}")
 
@@ -264,7 +267,7 @@ def cli_confirm(input_message: str, abort_message: str = "Did not confirm. Abort
     response = input(input_message).lower()
     if response not in {"y", "yes"}:
         print(abort_message)
-        raise click.Abort()
+        raise click.Abort
 
 
 def coin_selection_args(func: Callable[..., None]) -> Callable[..., None]:

chia/cmds/coin_funcs.py

@@ -12,13 +12,13 @@ from chia.cmds.cmd_helpers import WalletClientInfo
 from chia.cmds.cmds_util import CMDCoinSelectionConfigLoader, CMDTXConfigLoader, cli_confirm
 from chia.cmds.param_types import CliAmount
 from chia.cmds.wallet_funcs import get_mojo_per_unit, get_wallet_type, print_balance
-from chia.rpc.wallet_request_types import CombineCoins, SplitCoins
 from chia.types.blockchain_format.coin import Coin
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import selected_network_address_prefix
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.wallet_request_types import CombineCoins, SplitCoins
 
 
 async def async_list(
@@ -92,7 +92,7 @@ def print_coins(
         return
     num_per_screen = 5 if paginate else len(coins)
     for i in range(0, len(coins), num_per_screen):
-        for j in range(0, num_per_screen):
+        for j in range(num_per_screen):
             if i + j >= len(coins):
                 break
             coin, conf_height = coins[i + j]

chia/cmds/configure.py

@@ -7,13 +7,13 @@ import click
 import yaml
 
 from chia.cmds.cmd_classes import ChiaCliContext
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
+from chia.server.resolve_peer_info import set_peer_info
 from chia.util.config import (
     initial_config_file,
     load_defaults_for_missing_services,
     lock_and_load_config,
     save_config,
-    set_peer_info,
     str2bool,
 )
 

chia/cmds/data.py

@@ -13,8 +13,6 @@ from chia_rs.sized_ints import uint64
 from chia.cmds import options
 from chia.cmds.param_types import Bytes32ParamType
 
-_T = TypeVar("_T")
-
 FC = TypeVar("FC", bound=Union[Callable[..., Any], click.Command])
 
 logger = logging.getLogger(__name__)

chia/cmds/data_funcs.py

@@ -10,7 +10,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 from chia.cmds.cmds_util import get_any_service_client
-from chia.rpc.data_layer_rpc_client import DataLayerRpcClient
+from chia.data_layer.data_layer_rpc_client import DataLayerRpcClient
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.default_root import resolve_root_path
 

chia/cmds/db_validate_func.py

@@ -3,12 +3,11 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any, Optional
 
+from chia_rs import BlockRecord, FullBlock
 from chia_rs.sized_bytes import bytes32
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.types.full_block import FullBlock
 from chia.util.config import load_config
 from chia.util.path import path_from_root
 

chia/cmds/dev/data.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import dataclasses
+import datetime
+import logging
+import os
+import sysconfig
+import tempfile
+import time
+from dataclasses import field
+from pathlib import Path
+from typing import Any, Optional
+
+import aiohttp
+import anyio
+import click
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
+
+from chia.cmds.cmd_classes import ChiaCliContext, chia_command, option
+from chia.cmds.cmd_helpers import NeedsWalletRPC
+from chia.data_layer.data_layer import server_files_path_from_config
+from chia.data_layer.data_layer_util import ServerInfo, Status, Subscription
+from chia.data_layer.data_store import DataStore
+from chia.data_layer.download_data import insert_from_delta_file
+from chia.util.chia_logging import initialize_logging
+from chia.util.config import load_config
+from chia.util.task_referencer import create_referenced_task
+from chia.wallet.wallet_request_types import DLHistory, DLTrackNew
+
+
+class NonZeroReturnCodeError(Exception):
+    def __init__(self, returncode: int):
+        super().__init__(f"Process returned non-zero exit code: {returncode}")
+        self.returncode = returncode
+
+
+@dataclasses.dataclass
+class RunResult:
+    process: asyncio.subprocess.Process
+    stdout: Optional[str]
+    stderr: Optional[str]
+
+
+@click.group("data", help="For working with DataLayer")
+def data_group() -> None:
+    pass
+
+
+def print_date(*args: Any, **kwargs: Any) -> None:
+    kwargs.setdefault("flush", True)
+    s = datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds")
+    print(f"{s}:", *args, **kwargs)
+
+
+def humanize_bytes(size: int) -> str:
+    return f"{size / 2**20:.1f} MB"
+
+
+@chia_command(
+    group=data_group,
+    name="sync-time",
+    short_help="test time to sync a provided store id",
+    help="""
+        An empty temporary database is created and then the specified store is synced to it.
+        If local delta files are available in the specified directory then they will be used.
+        This allows both testing of total time including downloading as well as just the insert time.
+        The DataLayer work is done within the test process.
+        Separate daemon and wallet service processes are started and stopped.""",
+)
+class SyncTimeCommand:
+    wallet_rpc_info: NeedsWalletRPC
+    context: ChiaCliContext = field(default_factory=ChiaCliContext)
+    generation_limit: int = option("--generation-limit", required=True)
+    store_id: bytes32 = option("--store-id", required=True)
+    profile_tasks: bool = option("--profile-tasks/--no-profile-tasks")
+    restart_all: bool = option("--restart-all/--no-restart-all")
+    working_path: Optional[Path] = option("--working-path", default=None)
+
+    async def run(self) -> None:
+        config = load_config(self.context.root_path, "config.yaml", "data_layer", fill_missing_services=True)
+        initialize_logging(
+            service_name="data_layer_testing",
+            logging_config=config["logging"],
+            root_path=self.context.root_path,
+        )
+
+        if self.restart_all:
+            await self.run_chia("stop", "-d", "all", check=False)
+
+        await self.run_chia("start", "wallet")
+        await self.run_chia("keys", "generate", "--label", "for_testing")
+        await self.wait_for_wallet_synced()
+        await self.run_chia("wallet", "show")
+
+        try:
+            async with contextlib.AsyncExitStack() as exit_stack:
+                working_path: Path
+                if self.working_path is None:
+                    working_path = Path(exit_stack.enter_context(tempfile.TemporaryDirectory()))
+                else:
+                    working_path = self.working_path
+                    working_path.mkdir(parents=True, exist_ok=True)
+
+                database_path = working_path.joinpath("datalayer.sqlite")
+                print_date(f"working with database at: {database_path}")
+
+                wallet_client_info = await exit_stack.enter_async_context(self.wallet_rpc_info.wallet_rpc())
+                wallet_rpc = wallet_client_info.client
+                await wallet_rpc.dl_track_new(DLTrackNew(launcher_id=self.store_id))
+
+                data_store = await exit_stack.enter_async_context(DataStore.managed(database=database_path))
+
+                await data_store.subscribe(subscription=Subscription(store_id=self.store_id, servers_info=[]))
+
+                await self.wait_for_wallet_synced()
+                await self.run_chia("wallet", "show")
+
+                print_date("subscribed")
+
+                to_download = (
+                    await wallet_rpc.dl_history(
+                        DLHistory(
+                            launcher_id=self.store_id,
+                            min_generation=uint32(1),
+                            max_generation=uint32(self.generation_limit + 1),
+                        )
+                    )
+                ).history
+
+                print_date(
+                    f"found generations to download: {to_download[-1].generation} -> {to_download[0].generation}"
+                )
+
+                root_hashes = [record.root for record in reversed(to_download)]
+
+                files_path = server_files_path_from_config(config=config, root_path=self.context.root_path)
+
+                clock = time.monotonic
+                start = clock()
+
+                last_generation = -1
+                clock = time.monotonic
+                last_time = clock()
+                all_times: dict[int, float] = {}
+
+                print_date(f"using local files at: {files_path}")
+
+                await data_store.create_tree(store_id=self.store_id, status=Status.COMMITTED)
+
+                task = create_referenced_task(
+                    insert_from_delta_file(
+                        data_store=data_store,
+                        store_id=self.store_id,
+                        existing_generation=0,
+                        target_generation=self.generation_limit,
+                        root_hashes=root_hashes,
+                        server_info=ServerInfo(url="", num_consecutive_failures=0, ignore_till=0),
+                        client_foldername=files_path,
+                        timeout=aiohttp.ClientTimeout(),
+                        log=logging.getLogger(__name__),
+                        proxy_url=None,
+                        downloader=None,
+                        maximum_full_file_count=0,
+                    )
+                )
+                try:
+                    while not task.done():
+                        try:
+                            generation = await data_store.get_tree_generation(store_id=self.store_id)
+                        except Exception as e:
+                            if "No generations found" not in str(e):
+                                raise
+                        else:
+                            if generation != last_generation:
+                                delta_generation = generation - last_generation
+                                now = clock()
+                                delta_time = now - last_time
+                                per_generation = delta_time / delta_generation
+
+                                duration_so_far = round((now - start) / 60)
+
+                                print_date(
+                                    f"synced: {last_generation} -> {generation} at {per_generation:.1f}s / gen"
+                                    + f" ({humanize_bytes(database_path.stat().st_size)}, {duration_so_far}m)",
+                                    flush=True,
+                                )
+
+                                for i in range(generation, last_generation, -1):
+                                    all_times[i] = per_generation
+
+                                last_generation = generation
+                                last_time = now
+                        await asyncio.sleep(1)
+                finally:
+                    try:
+                        with anyio.CancelScope(shield=True):
+                            if task.done():
+                                await task
+                            else:
+                                task.cancel()
+                                with contextlib.suppress(asyncio.CancelledError):
+                                    await task
+                    finally:
+                        end = clock()
+                        total = round(end - start)
+                        remainder, seconds = divmod(total, 60)
+                        remainder, minutes = divmod(remainder, 60)
+                        days, hours = divmod(remainder, 24)
+                        # TODO: report better on failure
+                        print_date("DataLayer sync timing test results:")
+                        print(f"    store id: {self.store_id}")
+                        print(f"     reached: {generation}")
+                        print(f"     db size: {humanize_bytes(database_path.stat().st_size)}")
+                        print(f"    duration: {days}d {hours}h {minutes}m {seconds}s")
+                        print(f"              {total}s")
+                        if len(all_times) > 0:
+                            generation, duration = max(all_times.items(), key=lambda item: item[1])
+                            print(f"         max: {generation} @ {duration:.1f}s")
+        finally:
+            with anyio.CancelScope(shield=True):
+                print_date("stopping services")
+                await self.run_chia("stop", "-d", "all", check=False)
+
+    async def wait_for_wallet_synced(self) -> None:
+        print_date("waiting for wallet to sync")
+        while True:
+            run_result = await self.run_chia(
+                "wallet",
+                "show",
+                stdout=asyncio.subprocess.PIPE,
+            )
+            assert run_result.stdout is not None, "must not be none due to piping it in the exec call"
+            if "Sync status: Synced" not in run_result.stdout:
+                await asyncio.sleep(1)
+                continue
+
+            print_date("wallet synced")
+            break
+
+    async def run_chia(self, *args: str, check: bool = True, **kwargs: Any) -> RunResult:
+        env = os.environ.copy()
+        venv_path = Path(sysconfig.get_path("scripts"))
+        env["PATH"] = os.pathsep.join([os.fspath(venv_path), env["PATH"]])
+        env["CHIA_DATA_LAYER_STOP_AFTER_GENERATION"] = str(self.generation_limit)
+        env["CHIA_ROOT"] = os.fspath(self.context.root_path)
+        env["CHIA_KEYS_ROOT"] = os.fspath(self.context.keys_root_path)
+
+        process = await asyncio.create_subprocess_exec(
+            # sys.executable,
+            # "-m",
+            "chia",
+            *args,
+            **kwargs,
+            env=env,
+        )
+        stdout_bytes, stderr_bytes = await process.communicate()
+        if stdout_bytes is None:
+            stdout = None
+        else:
+            stdout = stdout_bytes.decode("utf-8")
+        if stderr_bytes is None:
+            stderr = None
+        else:
+            stderr = stderr_bytes.decode("utf-8")
+        if check:
+            assert process.returncode is not None, "must not be none due to .communicate() called above"
+            if process.returncode != 0:
+                raise NonZeroReturnCodeError(process.returncode)
+
+        return RunResult(process=process, stdout=stdout, stderr=stderr)

chia/cmds/{gh.py → dev/gh.py}

@@ -8,7 +8,7 @@ import uuid
 import webbrowser
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Callable, ClassVar, Literal, Optional, Union, overload
+from typing import Callable, ClassVar, Literal, Optional, overload
 
 import anyio
 import click
@@ -21,9 +21,9 @@ 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"]]
+Oses = Literal["linux", "macos-arm", "macos-intel", "windows"]
+Method = Literal["GET", "POST"]
+Per = Literal["directory", "file"]
 
 all_oses: Sequence[Oses] = ("linux", "macos-arm", "macos-intel", "windows")
 
@@ -110,7 +110,7 @@ def gh_group() -> None:
 )
 class TestCMD:
     workflow_id: ClassVar[str] = "test.yml"
-    owner: str = option("-o", "--owner", help="Owner of the repo", type=str, default="Chia-Network")
+    owner: str = option("-w", "--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",

chia/cmds/dev/main.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import click
+
+from chia.cmds.dev.data import data_group
+from chia.cmds.dev.gh import gh_group
+from chia.cmds.dev.installers import installers_group
+from chia.cmds.dev.mempool import mempool_cmd
+from chia.cmds.dev.sim import sim_cmd
+
+
+@click.group("dev", help="Developer commands and tools")
+@click.pass_context
+def dev_cmd(ctx: click.Context) -> None:
+    pass
+
+
+dev_cmd.add_command(sim_cmd)
+dev_cmd.add_command(installers_group)
+dev_cmd.add_command(gh_group)
+dev_cmd.add_command(mempool_cmd)
+dev_cmd.add_command(data_group)

chia/cmds/dev/mempool.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+import click
+
+from chia.cmds.cmd_classes import ChiaCliContext
+from chia.cmds.dev.mempool_funcs import create_block_async, export_mempool_async, import_mempool_async
+
+
+@click.group("mempool", help="Debug the mempool")
+@click.pass_context
+def mempool_cmd(ctx: click.Context) -> None:
+    pass
+
+
+@click.command("import", help="Import mempool items from a JSON file", no_args_is_help=True)
+@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,
+)
+@click.argument("path", type=str)
+@click.pass_context
+def import_mempool_cmd(ctx: click.Context, rpc_port: Optional[int], path: str) -> None:
+    import asyncio
+
+    with open(path) as file:
+        source = file.read()
+
+    content = json.loads(source)
+
+    asyncio.run(import_mempool_async(rpc_port, ChiaCliContext.set_default(ctx).root_path, content))
+
+
+@click.command("export", help="Export mempool items to a JSON file", no_args_is_help=True)
+@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,
+)
+@click.argument("path", type=str)
+@click.pass_context
+def export_mempool_cmd(ctx: click.Context, rpc_port: Optional[int], path: str) -> None:
+    import asyncio
+
+    asyncio.run(export_mempool_async(rpc_port, ChiaCliContext.set_default(ctx).root_path, path))
+
+
+@click.command("create_block", help="Create a block bundle from the mempool, as if you farmed it")
+@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,
+)
+@click.pass_context
+def create_block_cmd(ctx: click.Context, rpc_port: Optional[int]) -> None:
+    import asyncio
+
+    asyncio.run(create_block_async(rpc_port, ChiaCliContext.set_default(ctx).root_path))
+
+
+mempool_cmd.add_command(import_mempool_cmd)
+mempool_cmd.add_command(export_mempool_cmd)
+mempool_cmd.add_command(create_block_cmd)

chia/cmds/dev/mempool_funcs.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from chia_rs import SpendBundle
+
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+
+
+async def import_mempool_async(
+    rpc_port: Optional[int],
+    root_path: Path,
+    content: dict[str, Any],
+) -> None:
+    from chia.cmds.cmds_util import get_any_service_client
+
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (node_client, _):
+        success = 0
+        failed = 0
+
+        for item in content["mempool_items"].values():
+            try:
+                await node_client.push_tx(SpendBundle.from_json_dict(item["spend_bundle"]))
+                success += 1
+            except Exception:
+                failed += 1
+
+        print(f"Successfully imported {success} mempool items, but failed to import {failed}")
+
+
+async def export_mempool_async(
+    rpc_port: Optional[int],
+    root_path: Path,
+    path: str,
+) -> None:
+    from chia.cmds.cmds_util import get_any_service_client
+
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (node_client, _):
+        items = await node_client.get_all_mempool_items()
+        content = {"mempool_items": {tx_id.hex(): item for tx_id, item in items.items()}}
+
+        with open(path, "w") as f:
+            json.dump(content, f)
+
+        print(f"Successfully exported {len(content['mempool_items'])} mempool items to {path}")
+
+
+async def create_block_async(
+    rpc_port: Optional[int],
+    root_path: Path,
+) -> None:
+    from chia.cmds.cmds_util import get_any_service_client
+
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (node_client, _):
+        start = time.monotonic()
+        block = await node_client.create_block_generator()
+        end = time.monotonic()
+        assert block is not None
+        gen = block["generator"]
+        print(f"Successfully created block generator in {end - start} seconds of {len(gen)} bytes")