chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/cmds/farm_funcs.py

@@ -11,6 +11,7 @@ from chia.cmds.cmds_util import format_bytes, format_minutes, get_any_service_cl
 from chia.cmds.units import units
 from chia.farmer.farmer_rpc_client import FarmerRpcClient
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.util.config import lock_and_load_config, save_config
 from chia.util.errors import CliRpcConnectionError
 from chia.util.network import is_localhost
 from chia.wallet.wallet_rpc_client import WalletRpcClient
@@ -49,9 +50,13 @@ async def get_average_block_time(rpc_port: Optional[int], root_path: Path) -> fl
         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 def get_wallets_stats(
+    wallet_rpc_port: Optional[int],
+    root_path: Path,
+    include_pool_rewards: bool,
+) -> 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()
+        return await wallet_client.get_farmed_amount(include_pool_rewards)
 
 
 async def get_challenges(root_path: Path, farmer_rpc_port: Optional[int]) -> Optional[list[dict[str, Any]]]:
@@ -80,6 +85,7 @@ async def summary(
     wallet_rpc_port: Optional[int],
     harvester_rpc_port: Optional[int],
     farmer_rpc_port: Optional[int],
+    include_pool_rewards: bool,
     root_path: Path,
 ) -> None:
     harvesters_summary = await get_harvesters_summary(farmer_rpc_port, root_path)
@@ -97,7 +103,7 @@ async def summary(
     wallet_not_ready: bool = False
     amounts = None
     try:
-        amounts = await get_wallets_stats(wallet_rpc_port, root_path)
+        amounts = await get_wallets_stats(wallet_rpc_port, root_path, include_pool_rewards)
     except CliRpcConnectionError:
         wallet_not_ready = True
     except Exception:
@@ -120,8 +126,21 @@ async def summary(
     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']}")
+        if include_pool_rewards:
+            print(f"Farmer rewards: {amounts['farmer_reward_amount'] / units['chia']}")
+            print(f"Pool rewards: {amounts['pool_reward_amount'] / units['chia']}")
+            print(f"Total rewards: {(amounts['farmer_reward_amount'] + amounts['pool_reward_amount']) / units['chia']}")
+            if blockchain_state is not None and blockchain_state["peak"] is not None:
+                peak_height = blockchain_state["peak"].height
+                blocks_since_last_farm = peak_height - amounts["last_height_farmed"]
+                print(f"Current/Last height farmed: {peak_height}/{amounts['last_height_farmed']}")
+                print(f"Blocks since last farmed: {blocks_since_last_farm}")
+                print(
+                    f"Time since last farmed: {format_minutes(int((blocks_since_last_farm * SECONDS_PER_BLOCK) / 60))}"
+                )
+        else:
+            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
@@ -199,3 +218,33 @@ async def summary(
             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")
+
+
+async def solver_connect(root_path: Path, farmer_rpc_port: Optional[int], solver_address: str) -> None:
+    from chia.util.network import parse_host_port
+
+    try:
+        host, port = parse_host_port(solver_address)
+    except ValueError:
+        print("Solver address must be in format [IP:Port]")
+        return
+    try:
+        with lock_and_load_config(root_path, "config.yaml") as config:
+            config["farmer"]["solver_peers"] = [{"host": host, "port": port}]
+            save_config(root_path, "config.yaml", config)
+        print(f"✓ Updated config with solver peer {host}:{port}")
+    except Exception as e:
+        print(f"✗ Failed to update config: {e}")
+        return
+    try:
+        async with get_any_service_client(FarmerRpcClient, root_path, farmer_rpc_port) as (farmer_client, _):
+            result = await farmer_client.connect_to_solver(host, port)
+            if result.get("success"):
+                print(f"✓ Connected to solver at {host}:{port}")
+            else:
+                error = result.get("error", "Unknown error")
+                print(f"✗ Failed to connect to solver: {error}")
+    except CliRpcConnectionError:
+        print("✗ Could not connect to farmer. Make sure farmer is running.")
+    except Exception as e:
+        print(f"✗ Error connecting to solver: {e}")

chia/cmds/init_funcs.py

@@ -298,6 +298,8 @@ def chia_init(
                 crawler_minimum_version_count=None,
                 seeder_domain_name="",
                 seeder_nameserver="",
+                set_solver_peer="",
+                set_solver_trusted_peers_only="",
             )
         if fix_ssl_permissions:
             fix_ssl(root_path)
@@ -324,6 +326,8 @@ def chia_init(
             crawler_minimum_version_count=None,
             seeder_domain_name="",
             seeder_nameserver="",
+            set_solver_peer="",
+            set_solver_trusted_peers_only="",
         )
     create_all_ssl(root_path)
     if fix_ssl_permissions:

chia/cmds/keys_funcs.py

@@ -743,11 +743,10 @@ def derive_child_key(
         if non_observer_derivation:
             assert current_sk is not None  # semantics above guarantee this
             current_sk = _derive_path(current_sk, path_indices)
+        elif current_sk is not None:
+            current_sk = _derive_path_unhardened(current_sk, path_indices)
         else:
-            if current_sk is not None:
-                current_sk = _derive_path_unhardened(current_sk, path_indices)
-            else:
-                current_pk = _derive_pk_unhardened(current_pk, path_indices)
+            current_pk = _derive_pk_unhardened(current_pk, path_indices)
 
         derivation_root_sk = current_sk
         derivation_root_pk = current_pk
@@ -768,13 +767,12 @@ def derive_child_key(
             assert derivation_root_sk is not None  # semantics above guarantee this
             sk = _derive_path(derivation_root_sk, [i])
             pk = sk.get_g1()
+        elif derivation_root_sk is not None:
+            sk = _derive_path_unhardened(derivation_root_sk, [i])
+            pk = sk.get_g1()
         else:
-            if derivation_root_sk is not None:
-                sk = _derive_path_unhardened(derivation_root_sk, [i])
-                pk = sk.get_g1()
-            else:
-                sk = None
-                pk = _derive_pk_unhardened(derivation_root_pk, [i])
+            sk = None
+            pk = _derive_pk_unhardened(derivation_root_pk, [i])
         hd_path: str = (
             " (" + hd_path_root + str(i) + ("n" if non_observer_derivation else "") + ")" if show_hd_path else ""
         )

chia/cmds/peer_funcs.py

@@ -5,24 +5,22 @@ from typing import Any, Optional
 
 from chia.cmds.cmds_util import NODE_TYPES, get_any_service_client
 from chia.rpc.rpc_client import RpcClient
+from chia.util.network import parse_host_port
 
 
 async def add_node_connection(rpc_client: RpcClient, add_connection: str) -> None:
-    if ":" not in add_connection:
-        print("Enter a valid IP and port in the following format: 10.5.4.3:8000")
-    else:
-        ip, port = (
-            ":".join(add_connection.split(":")[:-1]),
-            add_connection.split(":")[-1],
-        )
-        print(f"Connecting to {ip}, {port}")
+    try:
+        host, port = parse_host_port(add_connection)
+        print(f"Connecting to {host}, {port}")
         try:
-            result = await rpc_client.open_connection(ip, int(port))
+            result = await rpc_client.open_connection(host, port)
             err = result.get("error")
             if result["success"] is False or err is not None:
                 print(err)
         except Exception:
-            print(f"Failed to connect to {ip}:{port}")
+            print(f"Failed to connect to {host}:{port}")
+    except ValueError:
+        print("Enter a valid IP and port in the following format: 10.5.4.3:8000")
 
 
 async def remove_node_connection(rpc_client: RpcClient, remove_connection: str) -> None:

chia/cmds/plotnft_funcs.py

@@ -13,7 +13,7 @@ from typing import Any, Callable, Optional
 import aiohttp
 import click
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64
 
 from chia.cmds.cmd_helpers import WalletClientInfo
 from chia.cmds.cmds_util import (
@@ -43,11 +43,15 @@ from chia.wallet.util.address_type import AddressType
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_request_types import (
+    GetTransaction,
+    GetWalletBalance,
+    GetWallets,
     PWAbsorbRewards,
     PWJoinPool,
     PWSelfPool,
     PWStatus,
     TransactionEndpointResponse,
+    WalletInfoResponse,
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 
@@ -118,7 +122,7 @@ async def create(
         start = time.time()
         while time.time() - start < 10:
             await asyncio.sleep(0.1)
-            tx = await wallet_info.client.get_transaction(tx_record.name)
+            tx = (await wallet_info.client.get_transaction(GetTransaction(tx_record.name))).transaction
             if len(tx.sent_to) > 0:
                 print(transaction_submitted_msg(tx))
                 print(transaction_status_msg(wallet_info.fingerprint, tx_record.name))
@@ -159,8 +163,8 @@ async def pprint_pool_wallet_state(
         print(f"Target state: {PoolSingletonState(pool_wallet_info.target.state).name}")
         print(f"Target pool URL: {pool_wallet_info.target.pool_url}")
     if pool_wallet_info.current.state == PoolSingletonState.SELF_POOLING.value:
-        balances: dict[str, Any] = await wallet_client.get_wallet_balance(wallet_id)
-        balance = balances["confirmed_wallet_balance"]
+        balances = (await wallet_client.get_wallet_balance(GetWalletBalance(uint32(wallet_id)))).wallet_balance
+        balance = balances.confirmed_wallet_balance
         typ = WalletType(int(WalletType.POOLING_WALLET))
         address_prefix, scale = wallet_coin_unit(typ, address_prefix)
         print(f"Claimable balance: {print_balance(balance, scale, address_prefix)}")
@@ -194,15 +198,15 @@ async def pprint_pool_wallet_state(
 
 async def pprint_all_pool_wallet_state(
     wallet_client: WalletRpcClient,
-    get_wallets_response: list[dict[str, Any]],
+    get_wallets_response: list[WalletInfoResponse],
     address_prefix: str,
     pool_state_dict: dict[bytes32, dict[str, Any]],
 ) -> None:
     print(f"Wallet height: {(await wallet_client.get_height_info()).height}")
     print(f"Sync status: {'Synced' if (await wallet_client.get_sync_status()).synced else 'Not synced'}")
     for wallet_info in get_wallets_response:
-        pool_wallet_id = wallet_info["id"]
-        typ = WalletType(int(wallet_info["type"]))
+        pool_wallet_id = wallet_info.id
+        typ = WalletType(int(wallet_info.type))
         if typ == WalletType.POOLING_WALLET:
             pool_wallet_info = (await wallet_client.pw_status(PWStatus(uint32(pool_wallet_id)))).state
             await pprint_pool_wallet_state(
@@ -220,7 +224,7 @@ async def show(
     root_path: Path,
     wallet_id_passed_in: Optional[int],
 ) -> None:
-    summaries_response = await wallet_info.client.get_wallets()
+    summaries_response = await wallet_info.client.get_wallets(GetWallets())
     config = wallet_info.config
     address_prefix = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"]
     pool_state_dict: dict[bytes32, dict[str, Any]] = dict()
@@ -247,10 +251,12 @@ async def show(
                 )
             else:
                 await pprint_all_pool_wallet_state(
-                    wallet_info.client, summaries_response, address_prefix, pool_state_dict
+                    wallet_info.client, summaries_response.wallets, address_prefix, pool_state_dict
                 )
     except CliRpcConnectionError:  # we want to output this if we can't connect to the farmer
-        await pprint_all_pool_wallet_state(wallet_info.client, summaries_response, address_prefix, pool_state_dict)
+        await pprint_all_pool_wallet_state(
+            wallet_info.client, summaries_response.wallets, address_prefix, pool_state_dict
+        )
 
 
 async def get_login_link(launcher_id: bytes32, root_path: Path) -> None:
@@ -281,7 +287,7 @@ async def submit_tx_with_confirmation(
                 continue
             while time.time() - start < 10:
                 await asyncio.sleep(0.1)
-                tx = await wallet_client.get_transaction(tx_record.name)
+                tx = (await wallet_client.get_transaction(GetTransaction(tx_record.name))).transaction
                 if len(tx.sent_to) > 0:
                     print(transaction_submitted_msg(tx))
                     print(transaction_status_msg(fingerprint, tx_record.name))
@@ -296,7 +302,7 @@ async def wallet_id_lookup_and_check(wallet_client: WalletRpcClient, wallet_id:
     selected_wallet_id: int
 
     # absent network errors, this should not fail with an error
-    pool_wallets = await wallet_client.get_wallets(wallet_type=WalletType.POOLING_WALLET)
+    pool_wallets = (await wallet_client.get_wallets(GetWallets(type=uint16(WalletType.POOLING_WALLET)))).wallets
 
     if wallet_id is None:
         if len(pool_wallets) == 0:
@@ -305,11 +311,11 @@ async def wallet_id_lookup_and_check(wallet_client: WalletRpcClient, wallet_id:
             )
         if len(pool_wallets) > 1:
             raise CliRpcConnectionError("More than one pool wallet found. Use -i to specify pool wallet id.")
-        selected_wallet_id = pool_wallets[0]["id"]
+        selected_wallet_id = pool_wallets[0].id
     else:
         selected_wallet_id = wallet_id
 
-    if not any(wallet["id"] == selected_wallet_id for wallet in pool_wallets):
+    if not any(wallet.id == selected_wallet_id for wallet in pool_wallets):
         raise CliRpcConnectionError(f"Wallet with id: {selected_wallet_id} is not a pool wallet.")
 
     return selected_wallet_id
@@ -440,8 +446,10 @@ async def change_payout_instructions(launcher_id: bytes32, address: CliAddress,
     for pool_config in old_configs:
         if pool_config.launcher_id == launcher_id:
             id_found = True
-            pool_config = replace(pool_config, payout_instructions=puzzle_hash.hex())
-        new_pool_configs.append(pool_config)
+            new_pool_config = replace(pool_config, payout_instructions=puzzle_hash.hex())
+        else:
+            new_pool_config = pool_config
+        new_pool_configs.append(new_pool_config)
     if id_found:
         print(f"Launcher Id: {launcher_id.hex()} Found, Updating Config.")
         await update_pool_config(root_path, new_pool_configs)

chia/cmds/rpc.py

@@ -13,7 +13,17 @@ from chia_rs.sized_ints import uint16
 from chia.cmds.cmd_classes import ChiaCliContext
 from chia.util.config import load_config
 
-services: list[str] = ["crawler", "daemon", "farmer", "full_node", "harvester", "timelord", "wallet", "data_layer"]
+services: list[str] = [
+    "crawler",
+    "daemon",
+    "farmer",
+    "full_node",
+    "harvester",
+    "timelord",
+    "wallet",
+    "data_layer",
+    "solver",
+]
 
 
 async def call_endpoint(

chia/cmds/show_funcs.py

@@ -39,7 +39,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[st
 
     if synced:
         print("Current Blockchain Status: Full Node Synced")
-        print("\nPeak: Hash:", bytes32(peak.header_hash) if peak is not None else "")
+        print("\nPeak: Hash:", peak.header_hash if peak is not None else "")
     elif peak is not None and sync_mode:
         sync_max_block = blockchain_state["sync"]["sync_tip_height"]
         sync_current_block = blockchain_state["sync"]["sync_progress_height"]
@@ -48,7 +48,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[st
             f"({sync_max_block - sync_current_block} behind). "
             f"({sync_current_block * 100.0 / sync_max_block:2.2f}% synced)"
         )
-        print("Peak: Hash:", bytes32(peak.header_hash) if peak is not None else "")
+        print("Peak: Hash:", peak.header_hash if peak is not None else "")
     elif peak is not None:
         print(f"Current Blockchain Status: Not Synced. Peak height: {peak.height}")
     else:
@@ -59,7 +59,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[st
         if peak.is_transaction_block:
             peak_time = peak.timestamp
         else:
-            peak_hash = bytes32(peak.header_hash)
+            peak_hash = peak.header_hash
             curr = await node_client.get_block_record(peak_hash)
             while curr is not None and not curr.is_transaction_block:
                 curr = await node_client.get_block_record(curr.prev_hash)
@@ -88,7 +88,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[st
             curr = await node_client.get_block_record(curr.prev_hash)
 
         for b in added_blocks:
-            print(f"{b.height:>9} | {bytes32(b.header_hash)}")
+            print(f"{b.height:>9} | {b.header_hash}")
     else:
         print("Blockchain has no blocks yet")
     return False
@@ -125,7 +125,7 @@ async def print_block_from_hash(
             cost = str(full_block.transactions_info.cost)
             tx_filter_hash: Union[str, bytes32] = "Not a transaction block"
             if full_block.foliage_transaction_block:
-                tx_filter_hash = bytes32(full_block.foliage_transaction_block.filter_hash)
+                tx_filter_hash = full_block.foliage_transaction_block.filter_hash
             fees: Any = block.fees
         else:
             block_time_string = "Not a transaction block"

chia/cmds/solver.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import click
+
+from chia.cmds.cmd_classes import ChiaCliContext
+
+
+@click.group("solver", help="Manage your solver")
+def solver_cmd() -> None:
+    pass
+
+
+@solver_cmd.command("get_state", help="Get current solver state")
+@click.option(
+    "-sp",
+    "--solver-rpc-port",
+    help="Set the port where the Solver is hosting the RPC interface. See the rpc_port under solver in config.yaml",
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.pass_context
+def get_state_cmd(
+    ctx: click.Context,
+    solver_rpc_port: Optional[int],
+) -> None:
+    import asyncio
+
+    from chia.cmds.solver_funcs import get_state
+
+    asyncio.run(get_state(ChiaCliContext.set_default(ctx), solver_rpc_port))

chia/cmds/solver_funcs.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+from chia.cmds.cmd_classes import ChiaCliContext
+from chia.cmds.cmds_util import get_any_service_client
+from chia.solver.solver_rpc_client import SolverRpcClient
+
+
+async def get_state(
+    ctx: ChiaCliContext,
+    solver_rpc_port: Optional[int] = None,
+) -> None:
+    """Get solver state via RPC."""
+    try:
+        async with get_any_service_client(SolverRpcClient, ctx.root_path, solver_rpc_port) as (client, _):
+            response = await client.get_state()
+            print(json.dumps(response, indent=2))
+    except Exception as e:
+        print(f"Failed to get solver state: {e}")

chia/cmds/wallet.py

@@ -94,7 +94,7 @@ def get_transaction_cmd(
     "--limit",
     help="Max number of transactions to return",
     type=int,
-    default=(2**32 - 1),
+    default=(2**16 - 1),
     show_default=True,
     required=False,
 )