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

chia/cmds/keys_funcs.py

@@ -5,11 +5,10 @@ import os
 import sys
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 
-from chia.cmds.passphrase_funcs import obtain_current_passphrase
 from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import bech32_encode, convertbits, encode_puzzle_hash
@@ -25,7 +24,7 @@ from chia.util.keychain import (
     generate_mnemonic,
     mnemonic_to_seed,
 )
-from chia.util.keyring_wrapper import KeyringWrapper
+from chia.util.keyring_wrapper import KeyringWrapper, obtain_current_passphrase
 from chia.wallet.derive_keys import (
     master_pk_to_wallet_pk_unhardened,
     master_sk_to_farmer_sk,
@@ -174,8 +173,8 @@ def show_keys(
             msg = "Showing all public and private keys"
         print(msg)
 
-    def process_key_data(key_data: KeyData) -> Dict[str, Any]:
-        key: Dict[str, Any] = {}
+    def process_key_data(key_data: KeyData) -> dict[str, Any]:
+        key: dict[str, Any] = {}
         sk = key_data.private_key if key_data.secrets is not None else None
         if key_data.label is not None:
             key["label"] = key_data.label
@@ -252,7 +251,7 @@ def delete(fingerprint: int) -> None:
 
 def derive_pk_and_sk_from_hd_path(
     master_pk: G1Element, hd_path_root: str, master_sk: Optional[PrivateKey] = None
-) -> Tuple[G1Element, Optional[PrivateKey], str]:
+) -> tuple[G1Element, Optional[PrivateKey], str]:
     """
     Derive a private key from the provided HD path. Takes a master key and HD path as input,
     and returns the derived key and the HD path that was used to derive it.
@@ -264,7 +263,7 @@ def derive_pk_and_sk_from_hd_path(
         NONOBSERVER = 0
         OBSERVER = 1
 
-    path: List[str] = hd_path_root.split("/")
+    path: list[str] = hd_path_root.split("/")
     if len(path) == 0 or path[0] != "m":
         raise ValueError("Invalid HD path. Must start with 'm'")
 
@@ -273,7 +272,7 @@ def derive_pk_and_sk_from_hd_path(
     if len(path) > 0 and path[-1] == "":  # remove trailing slash
         path = path[:-1]
 
-    index_and_derivation_types: List[Tuple[int, DerivationType]] = []
+    index_and_derivation_types: list[tuple[int, DerivationType]] = []
 
     # Validate path
     for current_index_str in path:
@@ -361,9 +360,9 @@ def _clear_line_part(n: int) -> None:
 def _search_derived(
     current_pk: G1Element,
     current_sk: Optional[PrivateKey],
-    search_terms: Tuple[str, ...],
+    search_terms: tuple[str, ...],
     path: str,
-    path_indices: Optional[List[int]],
+    path_indices: Optional[list[int]],
     limit: int,
     non_observer_derivation: bool,
     show_progress: bool,
@@ -371,7 +370,7 @@ def _search_derived(
     search_private_key: bool,
     search_address: bool,
     prefix: str,
-) -> List[str]:  # Return a subset of search_terms that were found
+) -> list[str]:  # Return a subset of search_terms that were found
     """
     Performs a shallow search of keys derived from the current pk/sk for items matching
     the provided search terms.
@@ -384,15 +383,15 @@ def _search_derived(
         PRIVATE_KEY = "private key"
         WALLET_ADDRESS = "wallet address"
 
-    remaining_search_terms: Dict[str, None] = dict.fromkeys(search_terms)
+    remaining_search_terms: dict[str, None] = dict.fromkeys(search_terms)
     current_path: str = path
-    current_path_indices: List[int] = path_indices if path_indices is not None else []
-    found_search_terms: List[str] = []
+    current_path_indices: list[int] = path_indices if path_indices is not None else []
+    found_search_terms: list[str] = []
 
     assert not (non_observer_derivation and current_sk is None)
 
     for index in range(limit):
-        found_items: List[Tuple[str, str, DerivedSearchResultType]] = []
+        found_items: list[tuple[str, str, DerivedSearchResultType]] = []
         printed_match: bool = False
         current_index_str = str(index) + ("n" if non_observer_derivation else "")
         current_path += f"{current_index_str}"
@@ -480,11 +479,11 @@ def _search_derived(
 def search_derive(
     root_path: Path,
     fingerprint: Optional[int],
-    search_terms: Tuple[str, ...],
+    search_terms: tuple[str, ...],
     limit: int,
     non_observer_derivation: bool,
     show_progress: bool,
-    search_types: Tuple[str, ...],
+    search_types: tuple[str, ...],
     derive_from_hd_path: Optional[str],
     prefix: Optional[str],
     private_key: Optional[PrivateKey],
@@ -497,13 +496,13 @@ def search_derive(
     from time import perf_counter
 
     start_time = perf_counter()
-    remaining_search_terms: Dict[str, None] = dict.fromkeys(search_terms)  # poor man's ordered set
+    remaining_search_terms: dict[str, None] = dict.fromkeys(search_terms)  # poor man's ordered set
     search_address = "address" in search_types
     search_public_key = "public_key" in search_types
     search_private_key = "private_key" in search_types
 
     if prefix is None:
-        config: Dict[str, Any] = load_config(root_path, "config.yaml")
+        config: dict[str, Any] = load_config(root_path, "config.yaml")
         selected: str = config["selected_network"]
         prefix = config["network_overrides"]["config"][selected]["address_prefix"]
 
@@ -513,8 +512,8 @@ def search_derive(
         search_private_key = True
 
     if fingerprint is None and private_key is None:
-        public_keys: List[G1Element] = Keychain().get_all_public_keys()
-        private_keys: List[Optional[PrivateKey]] = [
+        public_keys: list[G1Element] = Keychain().get_all_public_keys()
+        private_keys: list[Optional[PrivateKey]] = [
             data.private_key if data.secrets is not None else None for data in Keychain().get_keys(include_secrets=True)
         ]
     elif fingerprint is None:
@@ -530,7 +529,7 @@ def search_derive(
         if sk is None and non_observer_derivation:
             continue
         current_path: str = ""
-        found_terms: List[str] = []
+        found_terms: list[str] = []
 
         if show_progress:
             print(f"Searching keys derived from: {pk.get_fingerprint()}")
@@ -571,7 +570,7 @@ def search_derive(
             current_path = hd_path_root
         # Otherwise derive from well-known derivation paths
         else:
-            current_path_indices: List[int] = [12381, 8444]
+            current_path_indices: list[int] = [12381, 8444]
             path_root: str = "m/"
             for i in [12381, 8444]:
                 path_root += f"{i}{'n' if non_observer_derivation else ''}/"
@@ -668,10 +667,10 @@ def derive_wallet_address(
         pk = sk.get_g1()
 
     if prefix is None:
-        config: Dict[str, Any] = load_config(root_path, "config.yaml")
+        config: dict[str, Any] = load_config(root_path, "config.yaml")
         selected: str = config["selected_network"]
         prefix = config["network_overrides"]["config"][selected]["address_prefix"]
-    path_indices: List[int] = [12381, 8444, 2]
+    path_indices: list[int] = [12381, 8444, 2]
     wallet_hd_path_root: str = "m/"
     for i in path_indices:
         wallet_hd_path_root += f"{i}{'n' if non_observer_derivation else ''}/"
@@ -728,7 +727,7 @@ def derive_child_key(
 
     # Key type was specified
     if key_type is not None:
-        path_indices: List[int] = [12381, 8444]
+        path_indices: list[int] = [12381, 8444]
         path_indices.append(
             {
                 "farmer": 0,
@@ -802,11 +801,11 @@ def private_key_for_fingerprint(fingerprint: int) -> Optional[PrivateKey]:
 
 
 def prompt_for_fingerprint() -> Optional[int]:
-    fingerprints: List[int] = [pk.get_fingerprint() for pk in Keychain().get_all_public_keys()]
+    fingerprints: list[int] = [pk.get_fingerprint() for pk in Keychain().get_all_public_keys()]
     while True:
         print("Choose key:")
         for i, fp in enumerate(fingerprints):
-            print(f"{i+1}) {fp}")
+            print(f"{i + 1}) {fp}")
         val = None
         while val is None:
             val = input("Enter a number to pick or q to quit: ")
@@ -826,7 +825,7 @@ def prompt_for_fingerprint() -> Optional[int]:
 
 def get_private_key_with_fingerprint_or_prompt(
     fingerprint: Optional[int],
-) -> Tuple[Optional[int], Optional[PrivateKey]]:
+) -> tuple[Optional[int], Optional[PrivateKey]]:
     """
     Get a private key with the specified fingerprint. If fingerprint is not
     specified, prompt the user to select a key.
@@ -851,8 +850,8 @@ def private_key_from_mnemonic_seed_file(filename: Path) -> PrivateKey:
 
 
 def resolve_derivation_master_key(
-    fingerprint_or_filename: Optional[Union[int, str, Path]]
-) -> Tuple[Optional[int], Optional[PrivateKey]]:
+    fingerprint_or_filename: Optional[Union[int, str, Path]],
+) -> tuple[Optional[int], Optional[PrivateKey]]:
     """
     Given a key fingerprint of file containing a mnemonic seed, return the private key.
     """

chia/cmds/netspace.py

@@ -4,6 +4,8 @@ from typing import Optional
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
+
 
 @click.command("netspace", help="Estimate total farmed space on the network")
 @click.option(
@@ -36,12 +38,13 @@ import click
     type=str,
     default="",
 )
-def netspace_cmd(rpc_port: Optional[int], delta_block_height: str, start: str) -> None:
+@click.pass_context
+def netspace_cmd(ctx: click.Context, 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
+    from chia.cmds.netspace_funcs import netstorge_async
 
-    asyncio.run(netstorge_async(rpc_port, delta_block_height, start))
+    asyncio.run(netstorge_async(ChiaCliContext.set_default(ctx).root_path, rpc_port, delta_block_height, start))

chia/cmds/netspace_funcs.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Optional
 
 from chia.cmds.cmds_util import format_bytes, get_any_service_client
@@ -7,11 +8,11 @@ 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:
+async def netstorge_async(root_path: Path, 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, _):
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (client, _):
         if delta_block_height:
             if start == "":
                 blockchain_state = await client.get_blockchain_state()

chia/cmds/param_types.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Optional, Union
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
 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
@@ -170,17 +171,26 @@ class AddressParamType(click.ParamType):
         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
+            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
+
+                # attempt to get cached prefix
+                expected_prefix: Optional[str] = None
+                root_path = DEFAULT_ROOT_PATH
+
+                if ctx is not None:
+                    context = ChiaCliContext.set_default(ctx)
+                    root_path = context.root_path
+                    expected_prefix = context.expected_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
+                if ctx is not None:
+                    context.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)

chia/cmds/passphrase.py

@@ -7,6 +7,7 @@ from typing import Optional
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
 from chia.util.config import load_config
 
 
@@ -34,7 +35,7 @@ def set_cmd(
     current_passphrase_file: Optional[TextIOWrapper],
     hint: Optional[str],
 ) -> None:
-    from .passphrase_funcs import (
+    from chia.cmds.passphrase_funcs import (
         async_update_daemon_passphrase_cache_if_running,
         read_passphrase_from_file,
         set_or_update_passphrase,
@@ -70,7 +71,7 @@ def set_cmd(
 
     if success:
         # Attempt to update the daemon's passphrase cache
-        root_path = ctx.obj["root_path"]
+        root_path = ChiaCliContext.set_default(ctx).root_path
         config = load_config(root_path, "config.yaml")
         sys.exit(asyncio.run(async_update_daemon_passphrase_cache_if_running(root_path, config)))
 
@@ -86,7 +87,7 @@ def set_cmd(
 )
 @click.pass_context
 def remove_cmd(ctx: click.Context, current_passphrase_file: Optional[TextIOWrapper]) -> None:
-    from .passphrase_funcs import (
+    from chia.cmds.passphrase_funcs import (
         async_update_daemon_passphrase_cache_if_running,
         read_passphrase_from_file,
         remove_passphrase,
@@ -98,7 +99,7 @@ def remove_cmd(ctx: click.Context, current_passphrase_file: Optional[TextIOWrapp
 
     if remove_passphrase(current_passphrase):
         # Attempt to update the daemon's passphrase cache
-        root_path = ctx.obj["root_path"]
+        root_path = ChiaCliContext.set_default(ctx).root_path
         config = load_config(root_path, "config.yaml")
         sys.exit(asyncio.run(async_update_daemon_passphrase_cache_if_running(root_path, config)))
 
@@ -110,7 +111,7 @@ def hint_cmd() -> None:
 
 @hint_cmd.command("display", help="Display the keyring passphrase hint")
 def display_hint() -> None:
-    from .passphrase_funcs import display_passphrase_hint
+    from chia.cmds.passphrase_funcs import display_passphrase_hint
 
     display_passphrase_hint()
 
@@ -118,13 +119,13 @@ def display_hint() -> None:
 @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
+    from chia.cmds.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
+    from chia.cmds.passphrase_funcs import remove_passphrase_hint
 
     remove_passphrase_hint()

chia/cmds/passphrase_funcs.py

@@ -2,25 +2,18 @@ from __future__ import annotations
 
 import os
 import sys
-import time
 from getpass import getpass
 from io import TextIOWrapper
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
+import click
 import colorama
 
-from chia.cmds.cmds_util import prompt_yes_no
 from chia.daemon.client import acquire_connection_to_daemon
-from chia.util.errors import KeychainMaxUnlockAttempts
 from chia.util.keychain import Keychain, supports_os_passphrase_storage
-from chia.util.keyring_wrapper import DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE, KeyringWrapper
+from chia.util.keyring_wrapper import DEFAULT_PASSPHRASE_IF_NO_MASTER_PASSPHRASE, obtain_current_passphrase
 
-DEFAULT_PASSPHRASE_PROMPT = (
-    colorama.Fore.YELLOW + colorama.Style.BRIGHT + "(Unlock Keyring)" + colorama.Style.RESET_ALL + " Passphrase: "
-)  # noqa: E501
-FAILED_ATTEMPT_DELAY = 0.5
-MAX_RETRIES = 3
 SAVE_MASTER_PASSPHRASE_WARNING = (
     colorama.Fore.YELLOW
     + colorama.Style.BRIGHT
@@ -31,49 +24,9 @@ SAVE_MASTER_PASSPHRASE_WARNING = (
 )
 
 
-def obtain_current_passphrase(prompt: str = DEFAULT_PASSPHRASE_PROMPT, use_passphrase_cache: bool = False) -> str:
-    """
-    Obtains the master passphrase for the keyring, optionally using the cached
-    value (if previously set). If the passphrase isn't already cached, the user is
-    prompted interactively to enter their passphrase a max of MAX_RETRIES times
-    before failing.
-    """
-
-    if use_passphrase_cache:
-        passphrase, validated = KeyringWrapper.get_shared_instance().get_cached_master_passphrase()
-        if passphrase:
-            # If the cached passphrase was previously validated, we assume it's... valid
-            if validated:
-                return passphrase
-
-            # Cached passphrase needs to be validated
-            if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
-                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
-                return passphrase
-            else:
-                # Cached passphrase is bad, clear the cache
-                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(None)
-
-    # Prompt interactively with up to MAX_RETRIES attempts
-    for i in range(MAX_RETRIES):
-        colorama.init()
-
-        passphrase = prompt_for_passphrase(prompt)
-
-        if KeyringWrapper.get_shared_instance().master_passphrase_is_valid(passphrase):
-            # If using the passphrase cache, and the user inputted a passphrase, update the cache
-            if use_passphrase_cache:
-                KeyringWrapper.get_shared_instance().set_cached_master_passphrase(passphrase, validated=True)
-            return passphrase
-
-        time.sleep(FAILED_ATTEMPT_DELAY)
-        print("Incorrect passphrase\n")
-    raise KeychainMaxUnlockAttempts()
-
-
 def verify_passphrase_meets_requirements(
     new_passphrase: str, confirmation_passphrase: str
-) -> Tuple[bool, Optional[str]]:
+) -> tuple[bool, Optional[str]]:
     match = new_passphrase == confirmation_passphrase
     min_length = Keychain.minimum_passphrase_length()
     meets_len_requirement = len(new_passphrase) >= min_length
@@ -88,13 +41,6 @@ def verify_passphrase_meets_requirements(
         raise Exception("Unexpected passphrase verification case")
 
 
-def prompt_for_passphrase(prompt: str) -> str:
-    if sys.platform == "win32" or sys.platform == "cygwin":
-        print(prompt, end="", flush=True)
-        prompt = ""
-    return getpass(prompt)
-
-
 def prompt_to_save_passphrase() -> bool:
     save: bool = False
 
@@ -122,7 +68,7 @@ def prompt_to_save_passphrase() -> bool:
                 colorama.init()
 
                 print(warning)
-            save = prompt_yes_no(f"Would you like to save your passphrase to the {location}?")
+            save = click.confirm(f"Would you like to save your passphrase to the {location}?", default=None)
 
     except Exception as e:
         print(f"Caught exception: {e}")
@@ -131,7 +77,7 @@ def prompt_to_save_passphrase() -> bool:
     return save
 
 
-def prompt_for_new_passphrase() -> Tuple[str, bool]:
+def prompt_for_new_passphrase() -> tuple[str, bool]:
     min_length: int = Keychain.minimum_passphrase_length()
     if min_length > 0:
         n = min_length
@@ -324,7 +270,7 @@ def remove_passphrase_hint() -> None:
         print("Passphrase hint was not removed")
 
 
-async def async_update_daemon_passphrase_cache_if_running(root_path: Path, config: Dict[str, Any]) -> None:
+async def async_update_daemon_passphrase_cache_if_running(root_path: Path, config: dict[str, Any]) -> None:
     """
     Attempt to connect to the daemon and update the cached passphrase
     """

chia/cmds/peer.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
 from chia.cmds.cmds_util import NODE_TYPES
 from chia.cmds.peer_funcs import peer_async
 
@@ -42,7 +43,7 @@ def peer_cmd(
         peer_async(
             node_type,
             rpc_port,
-            ctx.obj["root_path"],
+            ChiaCliContext.set_default(ctx).root_path,
             connections,
             add_connection,
             remove_connection,

chia/cmds/peer_funcs.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from chia.cmds.cmds_util import NODE_TYPES, get_any_service_client
 from chia.rpc.rpc_client import RpcClient
@@ -49,7 +49,7 @@ async def remove_node_connection(rpc_client: RpcClient, remove_connection: str)
     print(result_txt)
 
 
-async def print_connections(rpc_client: RpcClient, trusted_peers: Dict[str, Any], trusted_cidrs: List[str]) -> None:
+async def print_connections(rpc_client: RpcClient, trusted_peers: dict[str, Any], trusted_cidrs: list[str]) -> None:
     import time
 
     from chia.server.outbound_message import NodeType
@@ -116,11 +116,11 @@ async def peer_async(
     remove_connection: str,
 ) -> None:
     client_type = NODE_TYPES[node_type]
-    async with get_any_service_client(client_type, rpc_port, root_path) as (rpc_client, config):
+    async with get_any_service_client(client_type, root_path, rpc_port) as (rpc_client, config):
         # Check or edit node connections
         if show_connections:
-            trusted_peers: Dict[str, Any] = config[node_type].get("trusted_peers", {})
-            trusted_cidrs: List[str] = config[node_type].get("trusted_cidrs", [])
+            trusted_peers: dict[str, Any] = config[node_type].get("trusted_peers", {})
+            trusted_cidrs: list[str] = config[node_type].get("trusted_cidrs", [])
             await print_connections(rpc_client, trusted_peers, trusted_cidrs)
             # if called together with state, leave a blank line
         if add_connection: