chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/cmds/cmd_classes.py

@@ -2,20 +2,19 @@ from __future__ import annotations
 
 import asyncio
 import collections
+import dataclasses
 import inspect
+import pathlib
 import sys
-from contextlib import asynccontextmanager
 from dataclasses import MISSING, dataclass, field, fields
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
-    List,
+    ClassVar,
     Optional,
     Protocol,
-    Type,
     Union,
+    final,
     get_args,
     get_origin,
     get_type_hints,
@@ -24,10 +23,9 @@ from typing import (
 import click
 from typing_extensions import dataclass_transform
 
-from chia.cmds.cmds_util import get_wallet_client
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
+from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.streamable import is_type_SpecificOptional
 
 SyncCmd = Callable[..., None]
@@ -53,7 +51,7 @@ def option(*param_decls: str, **kwargs: Any) -> Any:
     else:
         default_default = MISSING
 
-    return field(  # pylint: disable=invalid-field-call
+    return field(
         metadata=dict(
             option_args=dict(
                 param_decls=tuple(param_decls),
@@ -64,6 +62,29 @@ def option(*param_decls: str, **kwargs: Any) -> Any:
     )
 
 
+@final
+@dataclasses.dataclass
+class ChiaCliContext:
+    context_dict_key: ClassVar[str] = "_chia_cli_context"
+
+    root_path: pathlib.Path = DEFAULT_ROOT_PATH
+    expected_prefix: Optional[str] = None
+    rpc_port: Optional[int] = None
+    keys_fingerprint: Optional[int] = None
+    keys_filename: Optional[str] = None
+    expected_address_prefix: Optional[str] = None
+
+    @classmethod
+    def set_default(cls, ctx: click.Context) -> ChiaCliContext:
+        ctx.ensure_object(dict)
+        self = ctx.obj.setdefault(cls.context_dict_key, cls())
+        assert isinstance(self, cls)
+        return self
+
+    def to_click(self) -> dict[str, object]:
+        return {self.context_dict_key: self}
+
+
 class HexString(click.ParamType):
     name = "hexstring"
 
@@ -96,10 +117,10 @@ _CLASS_TYPES_TO_CLICK_TYPES = {
 
 @dataclass
 class _CommandParsingStage:
-    my_dataclass: Type[ChiaCommand]
-    my_option_decorators: List[Callable[[SyncCmd], SyncCmd]]
-    my_members: Dict[str, _CommandParsingStage]
-    my_kwarg_names: List[str]
+    my_dataclass: type[ChiaCommand]
+    my_option_decorators: list[Callable[[SyncCmd], SyncCmd]]
+    my_members: dict[str, _CommandParsingStage]
+    my_kwarg_names: list[str]
     _needs_context: bool
 
     def needs_context(self) -> bool:
@@ -108,14 +129,14 @@ class _CommandParsingStage:
         else:
             return any(member.needs_context() for member in self.my_members.values())
 
-    def get_all_option_decorators(self) -> List[Callable[[SyncCmd], SyncCmd]]:
-        all_option_decorators: List[Callable[[SyncCmd], SyncCmd]] = self.my_option_decorators
+    def get_all_option_decorators(self) -> list[Callable[[SyncCmd], SyncCmd]]:
+        all_option_decorators: list[Callable[[SyncCmd], SyncCmd]] = self.my_option_decorators
         for member in self.my_members.values():
             all_option_decorators.extend(member.get_all_option_decorators())
         return all_option_decorators
 
     def initialize_instance(self, **kwargs: Any) -> ChiaCommand:
-        kwargs_to_pass: Dict[str, Any] = {}
+        kwargs_to_pass: dict[str, Any] = {}
         for kwarg_name in self.my_kwarg_names:
             kwargs_to_pass[kwarg_name] = kwargs[kwarg_name]
 
@@ -130,7 +151,7 @@ class _CommandParsingStage:
 
             def strip_click_context(func: SyncCmd) -> SyncCmd:
                 def _inner(ctx: click.Context, **kwargs: Any) -> None:
-                    context: Dict[str, Any] = ctx.obj if ctx.obj is not None else {}
+                    context = ChiaCliContext.set_default(ctx)
                     func(context=context, **kwargs)
 
                 return _inner
@@ -152,10 +173,10 @@ class _CommandParsingStage:
             instance.run()
 
 
-def _generate_command_parser(cls: Type[ChiaCommand]) -> _CommandParsingStage:
-    option_decorators: List[Callable[[SyncCmd], SyncCmd]] = []
-    kwarg_names: List[str] = []
-    members: Dict[str, _CommandParsingStage] = {}
+def _generate_command_parser(cls: type[ChiaCommand]) -> _CommandParsingStage:
+    option_decorators: list[Callable[[SyncCmd], SyncCmd]] = []
+    kwarg_names: list[str] = []
+    members: dict[str, _CommandParsingStage] = {}
     needs_context: bool = False
 
     hints = get_type_hints(cls)
@@ -166,13 +187,13 @@ def _generate_command_parser(cls: Type[ChiaCommand]) -> _CommandParsingStage:
         if getattr(hints[field_name], COMMAND_HELPER_ATTRIBUTE_NAME, False):
             members[field_name] = _generate_command_parser(hints[field_name])
         elif field_name == "context":
-            if hints[field_name] != Context:
+            if hints[field_name] != ChiaCliContext:
                 raise ValueError("only Context can be the hint for variables named 'context'")
             else:
                 needs_context = True
                 kwarg_names.append(field_name)
         elif "option_args" in _field.metadata:
-            option_args: Dict[str, Any] = {"multiple": False, "required": False}
+            option_args: dict[str, Any] = {"multiple": False, "required": False}
             option_args.update(_field.metadata["option_args"])
 
             if "type" not in option_args:
@@ -216,8 +237,9 @@ def _generate_command_parser(cls: Type[ChiaCommand]) -> _CommandParsingStage:
             option_decorators.append(
                 click.option(
                     *option_args["param_decls"],
+                    field_name,
                     type=type_arg,
-                    **{k: v for k, v in option_args.items() if k not in ("param_decls", "type")},
+                    **{k: v for k, v in option_args.items() if k not in {"param_decls", "type"}},
                 )
             )
 
@@ -230,86 +252,72 @@ def _generate_command_parser(cls: Type[ChiaCommand]) -> _CommandParsingStage:
     )
 
 
-def _convert_class_to_function(cls: Type[ChiaCommand]) -> SyncCmd:
+def _convert_class_to_function(cls: type[ChiaCommand]) -> SyncCmd:
     command_parser = _generate_command_parser(cls)
 
     return command_parser.apply_decorators(command_parser)
 
 
-@dataclass_transform()
-def chia_command(cmd: click.Group, name: str, help: str) -> Callable[[Type[ChiaCommand]], Type[ChiaCommand]]:
-    def _chia_command(cls: Type[ChiaCommand]) -> Type[ChiaCommand]:
+@dataclass_transform(frozen_default=True)
+def chia_command(
+    *,
+    group: Optional[click.Group] = None,
+    name: str,
+    short_help: str,
+    help: str,
+) -> Callable[[type[ChiaCommand]], type[ChiaCommand]]:
+    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
-            wrapped_cls: Type[ChiaCommand] = dataclass(  # type: ignore[assignment]
+            wrapped_cls: type[ChiaCommand] = dataclass(  # type: ignore[assignment]
                 frozen=True,
             )(cls)
         else:
-            wrapped_cls: Type[ChiaCommand] = dataclass(  # type: ignore[assignment]
+            wrapped_cls: type[ChiaCommand] = dataclass(  # type: ignore[assignment]
                 frozen=True,
                 kw_only=True,
             )(cls)
 
-        cmd.command(name, short_help=help)(_convert_class_to_function(wrapped_cls))
+        metadata = Metadata(
+            command=click.command(
+                name=name,
+                short_help=short_help,
+                help=help,
+            )(_convert_class_to_function(wrapped_cls))
+        )
+
+        setattr(wrapped_cls, _chia_command_metadata_attribute, metadata)
+        if group is not None:
+            group.add_command(metadata.command)
+
         return wrapped_cls
 
     return _chia_command
 
 
-@dataclass_transform()
-def command_helper(cls: Type[Any]) -> Type[Any]:
+_chia_command_metadata_attribute = f"_{__name__.replace('.', '_')}_{chia_command.__qualname__}_metadata"
+
+
+@dataclass(frozen=True)
+class Metadata:
+    command: click.Command
+
+
+def get_chia_command_metadata(cls: type[ChiaCommand]) -> Metadata:
+    metadata: Optional[Metadata] = getattr(cls, _chia_command_metadata_attribute, None)
+    if metadata is None:
+        raise Exception(f"Class is not a chia command: {cls}")
+
+    return 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:
         new_cls = dataclass(frozen=True, kw_only=True)(cls)
     setattr(new_cls, COMMAND_HELPER_ATTRIBUTE_NAME, True)
     return new_cls
-
-
-Context = Dict[str, Any]
-
-
-@dataclass(frozen=True)
-class WalletClientInfo:
-    client: WalletRpcClient
-    fingerprint: int
-    config: Dict[str, Any]
-
-
-@command_helper
-class NeedsWalletRPC:
-    context: Context = field(default_factory=dict)  # pylint: disable=invalid-field-call
-    client_info: Optional[WalletClientInfo] = None
-    wallet_rpc_port: Optional[int] = 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,
-    )
-    fingerprint: Optional[int] = option(
-        "-f",
-        "--fingerprint",
-        help="Fingerprint of the wallet to use",
-        type=int,
-        default=None,
-    )
-
-    @asynccontextmanager
-    async def wallet_rpc(self, **kwargs: Any) -> AsyncIterator[WalletClientInfo]:
-        if self.client_info is not None:
-            yield self.client_info
-        else:
-            if "root_path" not in kwargs:
-                kwargs["root_path"] = self.context["root_path"]  # pylint: disable=unsubscriptable-object
-            async with get_wallet_client(self.wallet_rpc_port, self.fingerprint, **kwargs) as (
-                wallet_client,
-                fp,
-                config,
-            ):
-                yield WalletClientInfo(wallet_client, fp, config)

chia/cmds/cmd_helpers.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Coroutine, Sequence
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Callable, Optional, TypeVar
+
+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.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.wallet.conditions import ConditionValidTimes
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
+
+
+@dataclass(frozen=True)
+class WalletClientInfo:
+    client: WalletRpcClient
+    fingerprint: int
+    config: dict[str, Any]
+
+
+@command_helper
+class NeedsWalletRPC:
+    context: ChiaCliContext = field(default_factory=ChiaCliContext)
+    client_info: Optional[WalletClientInfo] = None
+    wallet_rpc_port: Optional[int] = 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,
+    )
+    fingerprint: Optional[int] = option(
+        "-f",
+        "--fingerprint",
+        help="Fingerprint of the wallet to use",
+        type=int,
+        default=None,
+    )
+
+    @asynccontextmanager
+    async def wallet_rpc(self, **kwargs: Any) -> AsyncIterator[WalletClientInfo]:
+        if self.client_info is not None:
+            yield self.client_info
+        else:
+            root_path = kwargs.get("root_path", self.context.root_path)
+            async with get_wallet_client(root_path, self.wallet_rpc_port, self.fingerprint, **kwargs) as (
+                wallet_client,
+                fp,
+                config,
+            ):
+                yield WalletClientInfo(wallet_client, fp, config)
+
+
+@command_helper
+class TransactionsIn:
+    transaction_file_in: str = option(
+        "--transaction-file-in",
+        type=str,
+        help="Transaction file to use as input",
+        required=True,
+    )
+
+    @cached_property
+    def transaction_bundle(self) -> TransactionBundle:
+        with open(Path(self.transaction_file_in), "rb") as file:
+            return TransactionBundle.from_bytes(file.read())
+
+
+@command_helper
+class TransactionsOut:
+    transaction_file_out: Optional[str] = option(
+        "--transaction-file-out",
+        type=str,
+        default=None,
+        help="A file to write relevant transactions to",
+        required=False,
+    )
+
+    def handle_transaction_output(self, output: list[TransactionRecord]) -> None:
+        if self.transaction_file_out is None:
+            return
+        else:
+            with open(Path(self.transaction_file_out), "wb") as file:
+                file.write(bytes(TransactionBundle(output)))
+
+
+@command_helper
+class NeedsCoinSelectionConfig:
+    min_coin_amount: CliAmount = option(
+        "-ma",
+        "--min-coin-amount",
+        "--min-amount",
+        help="Ignore coins worth less then this much XCH or CAT units",
+        type=AmountParamType(),
+        required=False,
+        default=cli_amount_none,
+    )
+    max_coin_amount: CliAmount = option(
+        "-l",
+        "--max-coin-amount",
+        "--max-amount",
+        help="Ignore coins worth more then this much XCH or CAT units",
+        type=AmountParamType(),
+        required=False,
+        default=cli_amount_none,
+    )
+    coins_to_exclude: Sequence[bytes32] = option(
+        "--exclude-coin",
+        multiple=True,
+        type=Bytes32ParamType(),
+        help="Exclude this coin from being spent.",
+    )
+    amounts_to_exclude: Sequence[CliAmount] = option(
+        "--exclude-amount",
+        multiple=True,
+        type=AmountParamType(),
+        help="Exclude any coins with this XCH or CAT amount from being included.",
+    )
+
+    def load_coin_selection_config(self, mojo_per_unit: int) -> CoinSelectionConfig:
+        return CMDCoinSelectionConfigLoader(
+            min_coin_amount=self.min_coin_amount,
+            max_coin_amount=self.max_coin_amount,
+            excluded_coin_amounts=list(_ for _ in self.amounts_to_exclude),
+            excluded_coin_ids=list(_ for _ in self.coins_to_exclude),
+        ).to_coin_selection_config(mojo_per_unit)
+
+
+@command_helper
+class NeedsTXConfig(NeedsCoinSelectionConfig):
+    reuse: Optional[bool] = option(
+        "--reuse/--new-address",
+        "--reuse-puzhash/--generate-new-puzhash",
+        help="Reuse existing address for the change.",
+        is_flag=True,
+        default=None,
+    )
+
+    def load_tx_config(self, mojo_per_unit: int, config: dict[str, Any], fingerprint: int) -> TXConfig:
+        return CMDTXConfigLoader(
+            min_coin_amount=self.min_coin_amount,
+            max_coin_amount=self.max_coin_amount,
+            excluded_coin_amounts=list(_ for _ in self.amounts_to_exclude),
+            excluded_coin_ids=list(_ for _ in self.coins_to_exclude),
+            reuse_puzhash=self.reuse,
+        ).to_tx_config(mojo_per_unit, config, fingerprint)
+
+
+def transaction_endpoint_runner(
+    func: Callable[[_T_TransactionEndpoint], Coroutine[Any, Any, list[TransactionRecord]]],
+) -> Callable[[_T_TransactionEndpoint], Coroutine[Any, Any, None]]:
+    async def wrapped_func(self: _T_TransactionEndpoint) -> None:
+        txs = await func(self)
+        self.transaction_writer.handle_transaction_output(txs)
+
+    setattr(wrapped_func, _TRANSACTION_ENDPOINT_DECORATOR_APPLIED, True)
+    return wrapped_func
+
+
+_TRANSACTION_ENDPOINT_DECORATOR_APPLIED = (
+    f"_{__name__.replace('.', '_')}_{transaction_endpoint_runner.__qualname__}_applied"
+)
+
+
+@dataclass(frozen=True)
+class TransactionEndpoint:
+    rpc_info: NeedsWalletRPC
+    tx_config_loader: NeedsTXConfig
+    transaction_writer: TransactionsOut
+    fee: uint64 = option(
+        "-m",
+        "--fee",
+        help="Set the fees for the transaction, in XCH",
+        type=TransactionFeeParamType(),
+        default="0",
+        show_default=True,
+        required=True,
+    )
+    push: bool = option(
+        "--push/--no-push", help="Push the transaction to the network", type=bool, is_flag=True, default=True
+    )
+    valid_at: Optional[int] = option(
+        "--valid-at",
+        help="UNIX timestamp at which the associated transactions become valid",
+        type=int,
+        required=False,
+        default=None,
+        hidden=True,
+    )
+    expires_at: Optional[int] = option(
+        "--expires-at",
+        help="UNIX timestamp at which the associated transactions expire",
+        type=int,
+        required=False,
+        default=None,
+        hidden=True,
+    )
+
+    def __post_init__(self) -> None:
+        if not hasattr(self.run, _TRANSACTION_ENDPOINT_DECORATOR_APPLIED):
+            raise TypeError("TransactionEndpoints must utilize @transaction_endpoint_runner on their `run` method")
+
+    def load_condition_valid_times(self) -> ConditionValidTimes:
+        return ConditionValidTimes(
+            min_time=uint64.construct_optional(self.valid_at),
+            max_time=uint64.construct_optional(self.expires_at),
+        )
+
+    @transaction_endpoint_runner
+    async def run(self) -> list[TransactionRecord]:
+        raise NotImplementedError("Must implement `.run()` on a TransactionEndpoint subclass")  # pragma: no cover
+
+
+@dataclass(frozen=True)
+class TransactionEndpointWithTimelocks(TransactionEndpoint):
+    valid_at: Optional[int] = option(
+        "--valid-at",
+        help="UNIX timestamp at which the associated transactions become valid",
+        type=int,
+        required=False,
+        default=None,
+    )
+    expires_at: Optional[int] = option(
+        "--expires-at",
+        help="UNIX timestamp at which the associated transactions expire",
+        type=int,
+        required=False,
+        default=None,
+    )
+
+
+_T_TransactionEndpoint = TypeVar("_T_TransactionEndpoint", bound=TransactionEndpoint)