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

chia/_tests/wallet/vc_wallet/test_vc_wallet.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Optional
 import pytest
 from chia_rs import G2Element
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint64
+from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from typing_extensions import Literal
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletStateTransition, WalletTestFramework
@@ -31,6 +31,9 @@ from chia.wallet.vc_wallet.vc_store import VCProofs, VCRecord
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_request_types import (
+    CATSpend,
+    GetTransactions,
+    GetWallets,
     VCAddProofs,
     VCGet,
     VCGetList,
@@ -38,6 +41,7 @@ from chia.wallet.wallet_request_types import (
     VCMint,
     VCRevoke,
     VCSpend,
+    WalletInfoResponse,
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
@@ -363,26 +367,32 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
         wallet_node_0.wallet_state_manager.main_wallet,
         (await wallet_node_0.wallet_state_manager.get_all_wallet_info_entries(wallet_type=WalletType.CRCAT))[0],
     )
-    assert {
-        "data": bytes(cr_cat_wallet_0.info).hex(),
-        "id": env_0.dealias_wallet_id("crcat"),
-        "name": cr_cat_wallet_0.get_name(),
-        "type": cr_cat_wallet_0.type(),
-        "authorized_providers": [p.hex() for p in cr_cat_wallet_0.info.authorized_providers],
-        "flags_needed": cr_cat_wallet_0.info.proofs_checker.flags,
-    } == (await client_0.get_wallets(wallet_type=cr_cat_wallet_0.type()))[0]
+    assert (
+        WalletInfoResponse(
+            data=bytes(cr_cat_wallet_0.info).hex(),
+            id=env_0.dealias_wallet_id("crcat"),
+            name=cr_cat_wallet_0.get_name(),
+            type=uint8(cr_cat_wallet_0.type()),
+            authorized_providers=cr_cat_wallet_0.info.authorized_providers,
+            flags_needed=cr_cat_wallet_0.info.proofs_checker.flags,
+        )
+        == (await client_0.get_wallets(GetWallets(type=uint16(cr_cat_wallet_0.type())))).wallets[0]
+    )
     assert await wallet_node_0.wallet_state_manager.get_wallet_for_asset_id(cr_cat_wallet_0.get_asset_id()) is not None
     async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         wallet_1_ph = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
     wallet_1_addr = encode_puzzle_hash(wallet_1_ph, "txch")
     txs = (
         await client_0.cat_spend(
-            cr_cat_wallet_0.id(),
+            CATSpend(
+                wallet_id=cr_cat_wallet_0.id(),
+                amount=uint64(90),
+                inner_address=wallet_1_addr,
+                fee=uint64(2000000000),
+                memos=["hey"],
+                push=True,
+            ),
             wallet_environments.tx_config,
-            uint64(90),
-            wallet_1_addr,
-            uint64(2000000000),
-            memos=["hey"],
         )
     ).transactions
     await wallet_environments.process_pending_states(
@@ -449,13 +459,17 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     assert await wallet_node_1.wallet_state_manager.wallets[env_1.dealias_wallet_id("crcat")].match_hinted_coin(
         next(c for tx in txs for c in tx.additions if c.amount == 90), wallet_1_ph
     )
-    pending_tx = await client_1.get_transactions(
-        env_1.dealias_wallet_id("crcat"),
-        0,
-        1,
-        reverse=True,
-        type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CRCAT_PENDING]),
-    )
+    pending_tx = (
+        await client_1.get_transactions(
+            GetTransactions(
+                uint32(env_1.dealias_wallet_id("crcat")),
+                uint16(0),
+                uint16(1),
+                reverse=True,
+                type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CRCAT_PENDING]),
+            )
+        )
+    ).transactions
     assert len(pending_tx) == 1
 
     # Send the VC to wallet_1 to use for the CR-CATs
@@ -547,10 +561,12 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     # (Negative test) Try to spend a CR-CAT that we don't have a valid VC for
     with pytest.raises(ValueError):
         await client_0.cat_spend(
-            cr_cat_wallet_0.id(),
-            wallet_environments.tx_config,
-            uint64(10),
-            wallet_1_addr,
+            CATSpend(
+                wallet_id=cr_cat_wallet_0.id(),
+                amount=uint64(10),
+                inner_address=wallet_1_addr,
+            ),
+            tx_config=wallet_environments.tx_config,
         )
 
     # Test melting a CRCAT
@@ -558,12 +574,17 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     with wallet_environments.new_puzzle_hashes_allowed():
         tx = (
             await client_1.cat_spend(
-                env_1.dealias_wallet_id("crcat"),
-                wallet_environments.tx_config,
-                uint64(20),
-                wallet_1_addr,
-                uint64(0),
-                cat_discrepancy=(-50, Program.to(None), Program.to(None)),
+                CATSpend(
+                    wallet_id=env_1.dealias_wallet_id("crcat"),
+                    amount=uint64(20),
+                    inner_address=wallet_1_addr,
+                    fee=uint64(0),
+                    extra_delta=str(-50),
+                    tail_reveal=b"\x80",
+                    tail_solution=b"\x80",
+                    push=True,
+                ),
+                tx_config=wallet_environments.tx_config,
             )
         ).transaction
     [tx] = await wallet_node_1.wallet_state_manager.add_pending_transactions([tx])
@@ -748,7 +769,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
     async with did_wallet.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=True
     ) as action_scope:
-        await did_wallet.transfer_did(bytes32.zeros, uint64(0), False, action_scope)
+        await did_wallet.transfer_did(bytes32.zeros, uint64(0), action_scope)
 
     await wallet_environments.process_pending_states(
         [

chia/apis.py

@@ -6,6 +6,7 @@ from chia.harvester.harvester_api import HarvesterAPI
 from chia.introducer.introducer_api import IntroducerAPI
 from chia.protocols.outbound_message import NodeType
 from chia.server.api_protocol import ApiProtocol
+from chia.solver.solver_api import SolverAPI
 from chia.timelord.timelord_api import TimelordAPI
 from chia.wallet.wallet_node_api import WalletNodeAPI
 
@@ -16,4 +17,5 @@ ApiProtocolRegistry: dict[NodeType, type[ApiProtocol]] = {
     NodeType.TIMELORD: TimelordAPI,
     NodeType.FARMER: FarmerAPI,
     NodeType.HARVESTER: HarvesterAPI,
+    NodeType.SOLVER: SolverAPI,
 }

chia/cmds/beta.py

@@ -92,10 +92,14 @@ def enable_cmd(ctx: click.Context, force: bool, path: Optional[str]) -> None:
         current_path = config.get("beta", {}).get("path")
         current_path = None if current_path is None else Path(current_path)
 
-        if path is None and current_path is None:
-            beta_root_path = prompt_for_beta_path(current_path or default_beta_root_path())
+        path_to_use: Optional[Path] = None if path is None else Path(path)
+        if path_to_use is None:
+            path_to_use = current_path
+
+        if path_to_use is None:
+            beta_root_path = prompt_for_beta_path(default_beta_root_path())
         else:
-            beta_root_path = Path(path or current_path)
+            beta_root_path = path_to_use
             validate_beta_path(beta_root_path)
 
         update_beta_config(True, beta_root_path, metrics_log_interval_default, config)

chia/cmds/chia.py

@@ -24,6 +24,7 @@ from chia.cmds.plots import plots_cmd
 from chia.cmds.plotters import plotters_cmd
 from chia.cmds.rpc import rpc_cmd
 from chia.cmds.show import show_cmd
+from chia.cmds.solver import solver_cmd
 from chia.cmds.start import start_cmd
 from chia.cmds.stop import stop_cmd
 from chia.cmds.wallet import wallet_cmd
@@ -127,6 +128,7 @@ cli.add_command(configure_cmd)
 cli.add_command(init_cmd)
 cli.add_command(rpc_cmd)
 cli.add_command(show_cmd)
+cli.add_command(solver_cmd)
 cli.add_command(start_cmd)
 cli.add_command(stop_cmd)
 cli.add_command(netspace_cmd)

chia/cmds/cmd_classes.py

@@ -5,7 +5,6 @@ import collections
 import dataclasses
 import inspect
 import pathlib
-import sys
 from dataclasses import MISSING, dataclass, field, fields
 from typing import (
     Any,
@@ -45,12 +44,6 @@ ChiaCommand = Union[SyncChiaCommand, AsyncChiaCommand]
 
 
 def option(*param_decls: str, **kwargs: Any) -> Any:
-    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
-
     return field(
         metadata=dict(
             option_args=dict(
@@ -58,7 +51,7 @@ def option(*param_decls: str, **kwargs: Any) -> Any:
                 **kwargs,
             ),
         ),
-        default=kwargs.get("default", default_default),
+        default=kwargs.get("default", MISSING),
     )
 
 
@@ -181,10 +174,10 @@ def _generate_command_parser(cls: type[ChiaCommand]) -> _CommandParsingStage:
     needs_context: bool = False
 
     hints = get_type_hints(cls)
-    _fields = fields(cls)  # type: ignore[arg-type]
+    cls_fields = fields(cls)  # type: ignore[arg-type]
 
-    for _field in _fields:
-        field_name = _field.name
+    for cls_field in cls_fields:
+        field_name = cls_field.name
         if getattr(hints[field_name], COMMAND_HELPER_ATTRIBUTE_NAME, False):
             members[field_name] = _generate_command_parser(hints[field_name])
         elif field_name == "context":
@@ -193,9 +186,9 @@ def _generate_command_parser(cls: type[ChiaCommand]) -> _CommandParsingStage:
             else:
                 needs_context = True
                 kwarg_names.append(field_name)
-        elif "option_args" in _field.metadata:
+        elif "option_args" in cls_field.metadata:
             option_args: dict[str, Any] = {"multiple": False, "required": False}
-            option_args.update(_field.metadata["option_args"])
+            option_args.update(cls_field.metadata["option_args"])
 
             if "type" not in option_args:
                 origin = get_origin(hints[field_name])
@@ -270,16 +263,10 @@ 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):
-            wrapped_cls: type[ChiaCommand] = dataclass(
-                frozen=True,
-                kw_only=True,
-            )(cls)
-        else:  # pragma: no cover
-            # stuff below 3.10 doesn't know about kw_only
-            wrapped_cls: type[ChiaCommand] = dataclass(
-                frozen=True,
-            )(cls)
+        wrapped_cls: type[ChiaCommand] = dataclass(
+            frozen=True,
+            kw_only=True,
+        )(cls)
 
         metadata = Metadata(
             command=click.command(
@@ -316,9 +303,6 @@ 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):
-        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
+    new_cls = dataclass(frozen=True, kw_only=True)(cls)
     setattr(new_cls, COMMAND_HELPER_ATTRIBUTE_NAME, True)
     return new_cls

chia/cmds/cmds_util.py

@@ -23,6 +23,7 @@ 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.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcClient
+from chia.solver.solver_rpc_client import SolverRpcClient
 from chia.types.mempool_submission_status import MempoolSubmissionStatus
 from chia.util.config import load_config
 from chia.util.errors import CliRpcConnectionError, InvalidPathError
@@ -42,6 +43,7 @@ NODE_TYPES: dict[str, type[RpcClient]] = {
     "harvester": HarvesterRpcClient,
     "data_layer": DataLayerRpcClient,
     "simulator": SimulatorFullNodeRpcClient,
+    "solver": SolverRpcClient,
 }
 
 node_config_section_names: dict[type[RpcClient], str] = {
@@ -52,6 +54,7 @@ node_config_section_names: dict[type[RpcClient], str] = {
     HarvesterRpcClient: "harvester",
     DataLayerRpcClient: "data_layer",
     SimulatorFullNodeRpcClient: "full_node",
+    SolverRpcClient: "solver",
 }
 
 _T_RpcClient = TypeVar("_T_RpcClient", bound=RpcClient)

chia/cmds/coin_funcs.py

@@ -18,7 +18,7 @@ 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
+from chia.wallet.wallet_request_types import CombineCoins, GetCoinRecordsByNames, GetSpendableCoins, SplitCoins
 
 
 async def async_list(
@@ -44,23 +44,28 @@ async def async_list(
     if not (await client_info.client.get_sync_status()).synced:
         print("Wallet not synced. Please wait.")
         return
-    conf_coins, unconfirmed_removals, unconfirmed_additions = await client_info.client.get_spendable_coins(
-        wallet_id=wallet_id,
-        coin_selection_config=CMDCoinSelectionConfigLoader(
-            max_coin_amount=max_coin_amount,
-            min_coin_amount=min_coin_amount,
-            excluded_coin_amounts=list(excluded_amounts),
-            excluded_coin_ids=list(excluded_coin_ids),
-        ).to_coin_selection_config(mojo_per_unit),
+    response = await client_info.client.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(wallet_id),
+            coin_selection_config=CMDCoinSelectionConfigLoader(
+                max_coin_amount=max_coin_amount,
+                min_coin_amount=min_coin_amount,
+                excluded_coin_amounts=list(excluded_amounts),
+                excluded_coin_ids=list(excluded_coin_ids),
+            ).to_coin_selection_config(mojo_per_unit),
+        )
+    )
+    print(
+        f"There are a total of {len(response.confirmed_records) + len(response.unconfirmed_additions)}"
+        f" coins in wallet {wallet_id}."
     )
-    print(f"There are a total of {len(conf_coins) + len(unconfirmed_additions)} coins in wallet {wallet_id}.")
-    print(f"{len(conf_coins)} confirmed coins.")
-    print(f"{len(unconfirmed_additions)} unconfirmed additions.")
-    print(f"{len(unconfirmed_removals)} unconfirmed removals.")
+    print(f"{len(response.confirmed_records)} confirmed coins.")
+    print(f"{len(response.unconfirmed_additions)} unconfirmed additions.")
+    print(f"{len(response.unconfirmed_removals)} unconfirmed removals.")
     print("Confirmed coins:")
     print_coins(
         "\tAddress: {} Amount: {}, Confirmed in block: {}\n",
-        [(cr.coin, str(cr.confirmed_block_index)) for cr in conf_coins],
+        [(cr.coin, str(cr.confirmed_block_index)) for cr in response.confirmed_records],
         mojo_per_unit,
         addr_prefix,
         paginate,
@@ -69,7 +74,7 @@ async def async_list(
         print("\nUnconfirmed Removals:")
         print_coins(
             "\tPrevious Address: {} Amount: {}, Confirmed in block: {}\n",
-            [(cr.coin, str(cr.confirmed_block_index)) for cr in unconfirmed_removals],
+            [(cr.coin, str(cr.confirmed_block_index)) for cr in response.unconfirmed_removals],
             mojo_per_unit,
             addr_prefix,
             paginate,
@@ -77,7 +82,7 @@ async def async_list(
         print("\nUnconfirmed Additions:")
         print_coins(
             "\tNew Address: {} Amount: {}, Not yet confirmed in a block.{}\n",
-            [(coin, "") for coin in unconfirmed_additions],
+            [(coin, "") for coin in response.unconfirmed_additions],
             mojo_per_unit,
             addr_prefix,
             paginate,
@@ -217,19 +222,19 @@ async def async_split(
         return []
 
     if number_of_coins is None:
-        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
-        if len(coins) == 0:
+        response = await client_info.client.get_coin_records_by_names(GetCoinRecordsByNames([target_coin_id]))
+        if len(response.coin_records) == 0:
             print("Could not find target coin.")
             return []
         assert amount_per_coin is not None
-        number_of_coins = int(coins[0].coin.amount // amount_per_coin.convert_amount(mojo_per_unit))
+        number_of_coins = int(response.coin_records[0].coin.amount // amount_per_coin.convert_amount(mojo_per_unit))
     elif amount_per_coin is None:
-        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
-        if len(coins) == 0:
+        response = await client_info.client.get_coin_records_by_names(GetCoinRecordsByNames([target_coin_id]))
+        if len(response.coin_records) == 0:
             print("Could not find target coin.")
             return []
         assert number_of_coins is not None
-        amount_per_coin = CliAmount(True, uint64(coins[0].coin.amount // number_of_coins))
+        amount_per_coin = CliAmount(True, uint64(response.coin_records[0].coin.amount // number_of_coins))
 
     final_amount_per_coin = amount_per_coin.convert_amount(mojo_per_unit)
 

chia/cmds/configure.py

@@ -16,11 +16,13 @@ from chia.util.config import (
     save_config,
     str2bool,
 )
+from chia.util.network import parse_host_port
 
 
 def configure(
     root_path: Path,
     set_farmer_peer: str,
+    set_solver_peer: str,
     set_node_introducer: str,
     set_fullnode_port: str,
     set_harvester_port: str,
@@ -34,6 +36,7 @@ def configure(
     crawler_minimum_version_count: Optional[int],
     seeder_domain_name: str,
     seeder_nameserver: str,
+    set_solver_trusted_peers_only: str,
 ) -> None:
     config_yaml = "config.yaml"
     with lock_and_load_config(root_path, config_yaml, fill_missing_services=True) as config:
@@ -42,30 +45,41 @@ def configure(
         change_made = False
         if set_node_introducer:
             try:
-                if set_node_introducer.index(":"):
-                    host, port = (
-                        ":".join(set_node_introducer.split(":")[:-1]),
-                        set_node_introducer.split(":")[-1],
-                    )
-                    config["full_node"]["introducer_peer"]["host"] = host
-                    config["full_node"]["introducer_peer"]["port"] = int(port)
-                    config["introducer"]["port"] = int(port)
-                    print("Node introducer updated")
-                    change_made = True
+                host, port = parse_host_port(set_node_introducer)
+                config["full_node"]["introducer_peer"]["host"] = host
+                config["full_node"]["introducer_peer"]["port"] = port
+                config["introducer"]["port"] = port
+                print("Node introducer updated")
+                change_made = True
             except ValueError:
                 print("Node introducer address must be in format [IP:Port]")
         if set_farmer_peer:
             try:
-                if set_farmer_peer.index(":"):
-                    host, port = (
-                        ":".join(set_farmer_peer.split(":")[:-1]),
-                        set_farmer_peer.split(":")[-1],
-                    )
-                    set_peer_info(config["harvester"], peer_type=NodeType.FARMER, peer_host=host, peer_port=int(port))
-                    print("Farmer peer updated, make sure your harvester has the proper cert installed")
-                    change_made = True
+                host, port = parse_host_port(set_farmer_peer)
+                set_peer_info(config["harvester"], peer_type=NodeType.FARMER, peer_host=host, peer_port=port)
+                print("Farmer peer updated, make sure your harvester has the proper cert installed")
+                change_made = True
             except ValueError:
                 print("Farmer address must be in format [IP:Port]")
+        if set_solver_peer:
+            try:
+                host, port = parse_host_port(set_solver_peer)
+                # ensure farmer section has solver_peers field
+                if "solver_peers" not in config["farmer"]:
+                    config["farmer"]["solver_peers"] = []
+                # Set single solver peer (overrides any existing)
+                config["farmer"]["solver_peers"] = [{"host": host, "port": port}]
+                print(f"Solver peer updated to {host}:{port}")
+                change_made = True
+            except ValueError:
+                print("Solver address must be in format [IP:Port]")
+        if set_solver_trusted_peers_only:
+            config["solver"]["trusted_peers_only"] = str2bool(set_solver_trusted_peers_only)
+            if str2bool(set_solver_trusted_peers_only):
+                print("Solver will only accept trusted peer connections")
+            else:
+                print("Solver will accept connections from all peers")
+            change_made = True
         if set_fullnode_port:
             config["full_node"]["port"] = int(set_fullnode_port)
             config["full_node"]["introducer_peer"]["port"] = int(set_fullnode_port)
@@ -244,6 +258,12 @@ def configure(
 )
 @click.option("--set-node-introducer", help="Set the introducer for node - IP:Port", type=str)
 @click.option("--set-farmer-peer", help="Set the farmer peer for harvester - IP:Port", type=str)
+@click.option("--set-solver-peer", help="Set the solver peer for farmer - IP:Port", type=str)
+@click.option(
+    "--set-solver-trusted-peers-only",
+    help="Enable/disable trusted peer requirement for solver connections",
+    type=click.Choice(["true", "t", "false", "f"]),
+)
 @click.option(
     "--set-fullnode-port",
     help="Set the port to use for the fullnode, useful for testing",
@@ -299,6 +319,7 @@ def configure(
 def configure_cmd(
     ctx: click.Context,
     set_farmer_peer: str,
+    set_solver_peer: str,
     set_node_introducer: str,
     set_fullnode_port: str,
     set_harvester_port: str,
@@ -312,10 +333,12 @@ def configure_cmd(
     crawler_minimum_version_count: int,
     seeder_domain_name: str,
     seeder_nameserver: str,
+    set_solver_trusted_peers_only: str,
 ) -> None:
     configure(
         ChiaCliContext.set_default(ctx).root_path,
         set_farmer_peer,
+        set_solver_peer,
         set_node_introducer,
         set_fullnode_port,
         set_harvester_port,
@@ -329,4 +352,5 @@ def configure_cmd(
         crawler_minimum_version_count,
         seeder_domain_name,
         seeder_nameserver,
+        set_solver_trusted_peers_only,
     )

chia/cmds/dev/data.py

@@ -23,7 +23,7 @@ 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.data_store import DataStore, default_prefer_file_kv_blob_length
 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
@@ -78,6 +78,11 @@ class SyncTimeCommand:
     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)
+    prefer_db_kv_blob_length: int = option(
+        "--prefer-db-kv-blob-length",
+        default=default_prefer_file_kv_blob_length,
+        type=int,
+    )
 
     async def run(self) -> None:
         config = load_config(self.context.root_path, "config.yaml", "data_layer", fill_missing_services=True)
@@ -104,14 +109,28 @@ class SyncTimeCommand:
                     working_path = self.working_path
                     working_path.mkdir(parents=True, exist_ok=True)
 
+                print_date(f"working in: {working_path}")
+
                 database_path = working_path.joinpath("datalayer.sqlite")
-                print_date(f"working with database at: {database_path}")
+
+                merkle_blob_path = working_path.joinpath("merkle-blobs")
+                merkle_blob_path.mkdir(parents=True, exist_ok=True)
+
+                key_value_blob_path = working_path.joinpath("key-value-blobs")
+                key_value_blob_path.mkdir(parents=True, exist_ok=True)
 
                 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))
+                data_store = await exit_stack.enter_async_context(
+                    DataStore.managed(
+                        database=database_path,
+                        merkle_blobs_path=merkle_blob_path,
+                        key_value_blobs_path=key_value_blob_path,
+                        prefer_db_kv_blob_length=self.prefer_db_kv_blob_length,
+                    )
+                )
 
                 await data_store.subscribe(subscription=Subscription(store_id=self.store_id, servers_info=[]))
 

chia/cmds/farm.py

@@ -49,6 +49,13 @@ def farm_cmd() -> None:
     default=None,
     show_default=True,
 )
+@click.option(
+    "-i",
+    "--include-pool-rewards",
+    help="Include pool farming rewards in the total farmed amount",
+    is_flag=True,
+    default=False,
+)
 @click.pass_context
 def summary_cmd(
     ctx: click.Context,
@@ -56,6 +63,7 @@ def summary_cmd(
     wallet_rpc_port: Optional[int],
     harvester_rpc_port: Optional[int],
     farmer_rpc_port: Optional[int],
+    include_pool_rewards: bool,
 ) -> None:
     import asyncio
 
@@ -67,6 +75,7 @@ def summary_cmd(
             wallet_rpc_port,
             harvester_rpc_port,
             farmer_rpc_port,
+            include_pool_rewards,
             root_path=ChiaCliContext.set_default(ctx).root_path,
         )
     )
@@ -96,3 +105,26 @@ def challenges_cmd(ctx: click.Context, farmer_rpc_port: Optional[int], limit: in
     from chia.cmds.farm_funcs import challenges
 
     asyncio.run(challenges(ChiaCliContext.set_default(ctx).root_path, farmer_rpc_port, limit))
+
+
+@farm_cmd.command("connect-solver", help="Connect to a solver")
+@click.option(
+    "-fp",
+    "--farmer-rpc-port",
+    help="Set the port where the Farmer is hosting the RPC interface",
+    type=int,
+    default=None,
+    show_default=True,
+)
+@click.argument("solver_address", required=True)
+@click.pass_context
+def connect_solver_cmd(
+    ctx: click.Context,
+    farmer_rpc_port: Optional[int],
+    solver_address: str,
+) -> None:
+    import asyncio
+
+    from chia.cmds.farm_funcs import solver_connect
+
+    asyncio.run(solver_connect(ChiaCliContext.set_default(ctx).root_path, farmer_rpc_port, solver_address))