chia-blockchain 2.4.4__py3-none-any.whl

chia/cmds/netspace.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+
+@click.command("netspace", help="Estimate total farmed space on the network")
+@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. "
+        "[default: 8555]"
+    ),
+    type=int,
+    default=None,
+)
+@click.option(
+    "-d",
+    "--delta-block-height",
+    help=(
+        "Compare a block X blocks older to estimate total network space. "
+        "Defaults to 4608 blocks (~1 day) and Peak block as the starting block. "
+        "Use --start BLOCK_HEIGHT to specify starting block. "
+        "Use 192 blocks to estimate over the last hour."
+    ),
+    type=str,
+    default="4608",
+)
+@click.option(
+    "-s",
+    "--start",
+    help="Newest block used to calculate estimated total network space. Defaults to Peak block.",
+    type=str,
+    default="",
+)
+def netspace_cmd(rpc_port: Optional[int], delta_block_height: str, start: str) -> None:
+    """
+    Calculates the estimated space on the network given two block header hashes.
+    """
+    import asyncio
+
+    from .netspace_funcs import netstorge_async
+
+    asyncio.run(netstorge_async(rpc_port, delta_block_height, start))

chia/cmds/netspace_funcs.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from chia.cmds.cmds_util import format_bytes, get_any_service_client
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+
+async def netstorge_async(rpc_port: Optional[int], delta_block_height: str, start: str) -> None:
+    """
+    Calculates the estimated space on the network given two block header hashes.
+    """
+    async with get_any_service_client(FullNodeRpcClient, rpc_port) as (client, _):
+        if delta_block_height:
+            if start == "":
+                blockchain_state = await client.get_blockchain_state()
+                if blockchain_state["peak"] is None:
+                    print("No blocks in blockchain")
+                    return None
+
+                newer_block_height = blockchain_state["peak"].height
+            else:
+                newer_block = await client.get_block_record(bytes32.from_hexstr(start))
+                if newer_block is None:
+                    print("Block header hash", start, "not found.")
+                    return None
+                else:
+                    print("newer_height", newer_block.height)
+                    newer_block_height = newer_block.height
+
+            newer_block_header = await client.get_block_record_by_height(newer_block_height)
+            older_block_height = max(0, newer_block_height - int(delta_block_height))
+            older_block_header = await client.get_block_record_by_height(older_block_height)
+            assert newer_block_header is not None and older_block_header is not None
+            network_space_bytes_estimate = await client.get_network_space(
+                newer_block_header.header_hash, older_block_header.header_hash
+            )
+            print(
+                "Older Block\n"
+                f"Block Height: {older_block_header.height}\n"
+                f"Weight:           {older_block_header.weight}\n"
+                f"VDF Iterations:   {older_block_header.total_iters}\n"
+                f"Header Hash:      0x{older_block_header.header_hash}\n"
+            )
+            print(
+                "Newer Block\n"
+                f"Block Height: {newer_block_header.height}\n"
+                f"Weight:           {newer_block_header.weight}\n"
+                f"VDF Iterations:   {newer_block_header.total_iters}\n"
+                f"Header Hash:      0x{newer_block_header.header_hash}\n"
+            )
+            print(format_bytes(network_space_bytes_estimate))

chia/cmds/options.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any, Callable, TypeVar, Union
+
+import click
+
+from chia.cmds.param_types import TransactionFeeParamType
+
+FC = TypeVar("FC", bound=Union[Callable[..., Any], click.Command])
+
+
+def create_fingerprint(required: bool = False) -> Callable[[FC], FC]:
+    return click.option(
+        "-f",
+        "--fingerprint",
+        help="Fingerprint of the wallet to use",
+        required=required,
+        # TODO: should be uint32
+        type=int,
+    )
+
+
+def create_fee(message: str = "Set the fees for the transaction, in XCH", required: bool = True) -> Callable[[FC], FC]:
+    return click.option(
+        "-m",
+        "--fee",
+        help=message,
+        type=TransactionFeeParamType(),
+        default="0",
+        show_default=True,
+        required=required,
+    )

chia/cmds/param_types.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+from typing import Any, Callable, Optional, Union
+
+import click
+
+from chia.cmds.units import units
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.bech32m import bech32_decode, decode_puzzle_hash
+from chia.util.config import load_config, selected_network_address_prefix
+from chia.util.default_root import DEFAULT_ROOT_PATH
+from chia.util.ints import uint64
+from chia.wallet.util.address_type import AddressType
+
+one_decimal_mojo = Decimal("1e-12")
+
+
+def validate_uint64(
+    value: str,
+    fail_func: Callable[[str, Optional[click.Parameter], Optional[click.Context]], None],
+    param: Optional[click.Parameter],
+    ctx: Optional[click.Context],
+) -> uint64:
+    try:
+        d_value = Decimal(value)
+    except InvalidOperation as e:
+        fail_func(f"Value must be a valid number: {e}", param, ctx)
+    if d_value.is_signed():
+        fail_func("Value must be a positive integer", param, ctx)
+    if d_value != d_value.to_integral():
+        fail_func("Value must be an integer", param, ctx)
+    try:
+        u_value = uint64(value)
+    except ValueError:
+        fail_func("Value must be a valid uint64 number", param, ctx)
+    return u_value
+
+
+def validate_decimal_xch(
+    value: str,
+    fail_func: Callable[[str, Optional[click.Parameter], Optional[click.Context]], None],
+    param: Optional[click.Parameter],
+    ctx: Optional[click.Context],
+) -> Decimal:
+    try:
+        d_value = Decimal(value)
+    except InvalidOperation:
+        fail_func("Value must be decimal dotted value in XCH (e.g. 0.00005)", param, ctx)
+    if d_value.is_signed():
+        fail_func("Value can not be negative", param, ctx)
+    if d_value % one_decimal_mojo != Decimal(0):  # if there is a remainder, it contains a value smaller than one mojo
+        fail_func("Invalid amount of mojos, Partial mojos (Fractions of a mojo).", param, ctx)
+    return d_value
+
+
+class TransactionFeeParamType(click.ParamType):
+    """
+    A Click parameter type for transaction fees, which can be specified in XCH or mojos.
+    """
+
+    name: str = "XCH"  # type name for cli, TODO: Change once the mojo flag is implemented
+    value_limit: Decimal = Decimal("0.5")
+
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> uint64:
+        # suggested by click, but we are not using it to avoid possible misinterpretation of units.
+        # if isinstance(value, uint64):
+        #     return value
+        if not isinstance(value, str):
+            self.fail("Invalid Type, fee must be string.", param, ctx)
+        mojos = False  # TODO: Add unit logic
+        if mojos:
+            return validate_uint64(value, self.fail, param, ctx)
+        d_value = validate_decimal_xch(value, self.fail, param, ctx)
+        if not self.value_limit.is_zero() and d_value > self.value_limit:
+            self.fail(f"Fee must be in the range 0 to {self.value_limit}", param, ctx)
+        try:
+            return uint64(d_value * units["chia"])
+        except ValueError:
+            self.fail("Fee must be a valid uint64 number", param, ctx)
+
+
+@dataclass(frozen=True)
+class CliAmount:
+    """
+    A dataclass for TX / wallet amounts for both XCH and CAT, and of course mojos.
+    """
+
+    mojos: bool
+    amount: Union[uint64, Decimal, None]  # uint64 if mojos, Decimal if not, None if default value is none
+
+    def convert_amount_with_default(
+        self, mojo_per_unit: int, default_value: Optional[uint64] = uint64(0)
+    ) -> Optional[uint64]:
+        if self.amount is None:  # if the value is set to none, return the default value
+            return default_value
+        return self.convert_amount(mojo_per_unit)
+
+    def convert_amount(self, mojo_per_unit: int) -> uint64:
+        if self.mojos:
+            if not isinstance(self.amount, uint64):
+                raise ValueError("Amount must be a uint64 if mojos flag is set.")
+            return self.amount
+        if not isinstance(self.amount, Decimal):
+            raise ValueError("Amount must be a Decimal if mojos flag is not set.")
+        converted_amount = self.amount * mojo_per_unit
+        uint64_amount = uint64(converted_amount)
+        if uint64_amount != converted_amount:
+            raise ValueError(
+                "Too much decimal precision specified."
+                "Please use the units of the balance numbers from `chia wallet show`"
+            )
+        return uint64_amount
+
+
+class AmountParamType(click.ParamType):
+    """
+    A Click parameter type for TX / wallet amounts for both XCH and CAT, and of course mojos.
+    """
+
+    name: str = "XCH"  # type name for cli, TODO: Change once the mojo flag is implemented
+
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> CliAmount:
+        # suggested by click, but being left in as mojos flag makes default misrepresentation less likely.
+        if isinstance(value, CliAmount):
+            return value
+        if not isinstance(value, str):
+            self.fail("Invalid Type, amount must be string or CliAmount.", param, ctx)
+        mojos = False  # TODO: Add unit logic
+        if mojos:
+            m_value = validate_uint64(value, self.fail, param, ctx)
+            return CliAmount(mojos=True, amount=m_value)
+        d_value = validate_decimal_xch(value, self.fail, param, ctx)
+        return CliAmount(mojos=False, amount=d_value)
+
+
+@dataclass(frozen=True)
+class CliAddress:
+    """
+    A dataclass for the cli, with the address type and puzzle hash.
+    """
+
+    puzzle_hash: bytes32
+    original_address: str
+    address_type: AddressType
+
+    def validate_address_type(self, address_type: AddressType) -> str:
+        if self.address_type is not address_type:
+            raise ValueError(f"Address must be of type {address_type}")
+        return self.original_address
+
+    def validate_address_type_get_ph(self, address_type: AddressType) -> bytes32:
+        if self.address_type is not address_type:
+            raise ValueError(f"Address must be of type {address_type}")
+        return self.puzzle_hash
+
+
+class AddressParamType(click.ParamType):
+    """
+    A Click parameter type for bech32m encoded addresses, it gives a class with the address type and puzzle hash.
+    """
+
+    name: str = "Address"  # type name for cli
+
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> CliAddress:
+        # suggested by click, but not really used so removed to make unexpected types more obvious.
+        # if isinstance(value, CliAddress):
+        #    return value
+        if not isinstance(value, str):
+            self.fail("Invalid Type, address must be string.", param, ctx)
+        try:
+            hrp, b32data = bech32_decode(value)
+            if hrp in ["xch", "txch"]:  # I hate having to load the config here
+                addr_type: AddressType = AddressType.XCH
+                expected_prefix = ctx.obj.get("expected_prefix") if ctx else None  # attempt to get cached prefix
+                if expected_prefix is None:
+                    root_path = ctx.obj["root_path"] if ctx is not None else DEFAULT_ROOT_PATH
+                    config = load_config(root_path, "config.yaml")
+                    expected_prefix = selected_network_address_prefix(config)
+
+                    if ctx is not None:
+                        ctx.obj["expected_prefix"] = expected_prefix  # cache prefix
+                # now that we have the expected prefix, we can validate the address is for the right network
+                if hrp != expected_prefix:
+                    self.fail(f"Unexpected Address Prefix: {hrp}, are you sure its for the right network?", param, ctx)
+            else:  # all other address prefixes (Not xch / txch)
+                addr_type = AddressType(hrp)
+            return CliAddress(puzzle_hash=decode_puzzle_hash(value), address_type=addr_type, original_address=value)
+        except ValueError:
+            self.fail("Address must be a valid bech32m address", param, ctx)
+
+
+class Bytes32ParamType(click.ParamType):
+    """
+    A Click parameter type for bytes32 hex strings, with or without the 0x prefix.
+    """
+
+    name: str = "HexString"  # type name for cli
+
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> bytes32:
+        # suggested by click but deemed not necessary due to unnecessary complexity.
+        # if isinstance(value, bytes32):
+        #     return value
+        if not isinstance(value, str):
+            self.fail("Invalid Type, value must be string.", param, ctx)
+        try:
+            return bytes32.from_hexstr(value)
+        except ValueError:
+            self.fail("Value must be a valid bytes32 hex string like a coin id or puzzle hash", param, ctx)
+
+
+class Uint64ParamType(click.ParamType):
+    """
+    A Click parameter type for Uint64 integers.
+    """
+
+    name: str = uint64.__name__  # type name for cli
+
+    def convert(self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]) -> uint64:
+        if isinstance(value, uint64):  # required by click
+            return value
+        if not isinstance(value, str):
+            self.fail("Invalid Type, value must be string or uint64.", param, ctx)
+        return validate_uint64(value, self.fail, param, ctx)
+
+
+cli_amount_none = CliAmount(mojos=False, amount=None)

chia/cmds/passphrase.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+from io import TextIOWrapper
+from typing import Optional
+
+import click
+
+from chia.util.config import load_config
+
+
+@click.group("passphrase", help="Manage your keyring passphrase")
+def passphrase_cmd() -> None:
+    pass
+
+
+@passphrase_cmd.command(
+    "set",
+    help="""Sets or updates the keyring passphrase. If --passphrase-file and/or --current-passphrase-file options are
+            provided, the passphrases will be read from the specified files. Otherwise, a prompt will be provided to
+            enter the passphrase.""",
+    short_help="Set or update the keyring passphrase",
+)
+@click.option("--passphrase-file", type=click.File("r"), help="File or descriptor to read the passphrase from")
+@click.option(
+    "--current-passphrase-file", type=click.File("r"), help="File or descriptor to read the current passphrase from"
+)
+@click.option("--hint", type=str, help="Passphrase hint")
+@click.pass_context
+def set_cmd(
+    ctx: click.Context,
+    passphrase_file: Optional[TextIOWrapper],
+    current_passphrase_file: Optional[TextIOWrapper],
+    hint: Optional[str],
+) -> None:
+    from .passphrase_funcs import (
+        async_update_daemon_passphrase_cache_if_running,
+        read_passphrase_from_file,
+        set_or_update_passphrase,
+        verify_passphrase_meets_requirements,
+    )
+
+    success: bool = False
+    current_passphrase: Optional[str] = None
+    if current_passphrase_file is not None:
+        current_passphrase = read_passphrase_from_file(current_passphrase_file)
+
+    if passphrase_file is not None:
+        try:
+            # Read the passphrase from a file and verify it
+            new_passphrase: str = read_passphrase_from_file(passphrase_file)
+            valid_passphrase, error_msg = verify_passphrase_meets_requirements(
+                new_passphrase, new_passphrase
+            )  # new_passphrase provided for both args since we don't have a separate confirmation passphrase
+
+            if not valid_passphrase:
+                raise ValueError(f"{error_msg}")
+        except ValueError as e:
+            print(f"Unable to set passphrase: {e}")
+        except Exception as e:
+            print(f"Failed to read passphrase: {e}")
+        else:
+            # Interactively prompt for the current passphrase (if set)
+            success = set_or_update_passphrase(
+                passphrase=new_passphrase, current_passphrase=current_passphrase, hint=hint
+            )
+    else:
+        success = set_or_update_passphrase(passphrase=None, current_passphrase=current_passphrase, hint=hint)
+
+    if success:
+        # Attempt to update the daemon's passphrase cache
+        root_path = ctx.obj["root_path"]
+        config = load_config(root_path, "config.yaml")
+        sys.exit(asyncio.run(async_update_daemon_passphrase_cache_if_running(root_path, config)))
+
+
+@passphrase_cmd.command(
+    "remove",
+    help="""Remove the keyring passphrase. If the --current-passphrase-file option is provided, the passphrase will be
+            read from the specified file. Otherwise, a prompt will be provided to enter the passphrase.""",
+    short_help="Remove the keyring passphrase",
+)
+@click.option(
+    "--current-passphrase-file", type=click.File("r"), help="File or descriptor to read the current passphrase from"
+)
+@click.pass_context
+def remove_cmd(ctx: click.Context, current_passphrase_file: Optional[TextIOWrapper]) -> None:
+    from .passphrase_funcs import (
+        async_update_daemon_passphrase_cache_if_running,
+        read_passphrase_from_file,
+        remove_passphrase,
+    )
+
+    current_passphrase: Optional[str] = None
+    if current_passphrase_file is not None:
+        current_passphrase = read_passphrase_from_file(current_passphrase_file)
+
+    if remove_passphrase(current_passphrase):
+        # Attempt to update the daemon's passphrase cache
+        root_path = ctx.obj["root_path"]
+        config = load_config(root_path, "config.yaml")
+        sys.exit(asyncio.run(async_update_daemon_passphrase_cache_if_running(root_path, config)))
+
+
+@passphrase_cmd.group("hint", help="Manage the optional keyring passphrase hint")
+def hint_cmd() -> None:
+    pass
+
+
+@hint_cmd.command("display", help="Display the keyring passphrase hint")
+def display_hint() -> None:
+    from .passphrase_funcs import display_passphrase_hint
+
+    display_passphrase_hint()
+
+
+@hint_cmd.command("set", help="Set or update the keyring passphrase hint")
+@click.argument("hint", nargs=1)
+def set_hint(hint: str) -> None:
+    from .passphrase_funcs import set_passphrase_hint
+
+    set_passphrase_hint(hint)
+
+
+@hint_cmd.command("remove", help="Remove the keyring passphrase hint")
+def remove_hint() -> None:
+    from .passphrase_funcs import remove_passphrase_hint
+
+    remove_passphrase_hint()