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

chia/util/config.py

@@ -305,14 +305,12 @@ def selected_network_address_prefix(config: dict[str, Any]) -> str:
 
 
 def load_defaults_for_missing_services(config: dict[str, Any], config_name: str) -> dict[str, Any]:
-    services = ["data_layer"]
+    services = ["data_layer", "solver"]
     missing_services = [service for service in services if service not in config]
     defaulted = {}
     if len(missing_services) > 0:
         marshalled_default_config: str = initial_config_file(config_name)
-
         unmarshalled_default_config = yaml.safe_load(marshalled_default_config)
-
         for service in missing_services:
             defaulted[service] = unmarshalled_default_config[service]
 

chia/util/db_wrapper.py

@@ -124,15 +124,14 @@ def get_host_parameter_limit() -> int:
 
         limit_number = sqlite3.SQLITE_LIMIT_VARIABLE_NUMBER
         host_parameter_limit = connection.getlimit(limit_number)
-    else:
-        # guessing based on defaults, seems you can't query
+    # guessing based on defaults, seems you can't query
 
-        # https://www.sqlite.org/changes.html#version_3_32_0
-        # Increase the default upper bound on the number of parameters from 999 to 32766.
-        if sqlite3.sqlite_version_info >= (3, 32, 0):
-            host_parameter_limit = 32766
-        else:
-            host_parameter_limit = 999
+    # https://www.sqlite.org/changes.html#version_3_32_0
+    # Increase the default upper bound on the number of parameters from 999 to 32766.
+    elif sqlite3.sqlite_version_info >= (3, 32, 0):
+        host_parameter_limit = 32766
+    else:
+        host_parameter_limit = 999
     return host_parameter_limit
 
 

chia/util/initial-config.yaml

@@ -209,6 +209,11 @@ farmer:
     - host: *self_hostname
       port: 8444
 
+  # The farmer will attempt to connect to these solvers for V2 plot solving
+  solver_peers:
+    - host: *self_hostname
+      port: 8666
+
   pool_public_keys: !!set {}
 
   # Replace this with a real receive address
@@ -629,6 +634,42 @@ wallet:
 
   auto_sign_txs: True
 
+solver:
+  # The solver server will run on this port
+  port: 8666
+
+  # Enable or disable UPnP port forwarding
+  enable_upnp: False
+
+  # Node IDs of trusted solver peers, only these can connect by default
+  trusted_peers:
+    0ThisisanexampleNodeID7ff9d60f1c3fa270c213c0ad0cb89c01274634a7c3cb7: Does_not_matter
+
+  # If False, accepts connections from all peers (not just trusted_peers)
+  # If True (default), only accepts localhost and trusted_peers connections
+  trusted_peers_only: True
+
+  # Logging configuration
+  logging: *logging
+
+  # Network overrides and selected network
+  network_overrides: *network_overrides
+  selected_network: *selected_network
+
+  # Number of threads for solver operations
+  num_threads: 4
+
+  # RPC server configuration
+  rpc_port: 8667
+  start_rpc_server: True
+
+  # SSL configuration
+  ssl:
+    private_crt: "config/ssl/solver/private_solver.crt"
+    private_key: "config/ssl/solver/private_solver.key"
+    public_crt: "config/ssl/solver/public_solver.crt"
+    public_key: "config/ssl/solver/public_solver.key"
+
 data_layer:
   # TODO: consider name
   # TODO: organize consistently with other sections
@@ -637,6 +678,8 @@ data_layer:
     port: 9256
 
   database_path: "data_layer/db/data_layer_CHALLENGE.sqlite"
+  merkle_blobs_path: "data_layer/db/merkle_blobs_CHALLENGE"
+  key_value_blobs_path: "data_layer/db/key_value_blobs_CHALLENGE"
   # The location where the server files will be stored.
   server_files_location: "data_layer/db/server_files_location_CHALLENGE"
   # The timeout for the client to download a file from a server
@@ -679,6 +722,9 @@ data_layer:
   # Enable to store all .DAT files grouped by store id
   group_files_by_store: False
 
+  # Increasing this number may help sync old clients faster, at the expense of using more RAM memory
+  merkle_blobs_cache_size: 1
+
 simulator:
   # Should the simulator farm a block whenever a transaction is in mempool
   auto_farm: True

chia/util/lru_cache.py

@@ -22,10 +22,14 @@ class LRUCache(Generic[K, V]):
             return self.cache[key]
 
     def put(self, key: K, value: V) -> None:
-        self.cache[key] = value
-        self.cache.move_to_end(key)
-        if len(self.cache) > self.capacity:
-            self.cache.popitem(last=False)
+        if self.capacity > 0:
+            self.cache[key] = value
+            self.cache.move_to_end(key)
+            if len(self.cache) > self.capacity:
+                self.cache.popitem(last=False)
 
     def remove(self, key: K) -> None:
         self.cache.pop(key)
+
+    def get_capacity(self) -> int:
+        return self.capacity

chia/util/network.py

@@ -9,6 +9,7 @@ from collections.abc import Iterable
 from dataclasses import dataclass
 from ipaddress import IPv4Network, IPv6Network, ip_address
 from typing import Any, Literal, Optional, Union
+from urllib.parse import urlsplit
 
 from aiohttp import web
 from aiohttp.log import web_logger
@@ -20,6 +21,14 @@ from chia.util.ip_address import IPAddress
 from chia.util.task_referencer import create_referenced_task
 
 
+def parse_host_port(host_port: str) -> tuple[str, int]:
+    """Parse a host:port string into a tuple of (host, port), raising ValueError on failure."""
+    result = urlsplit(f"//{host_port}")
+    if result.hostname and result.port:
+        return result.hostname, result.port
+    raise ValueError(f"Invalid host:port string: {host_port}")
+
+
 @final
 @dataclass
 class WebServer:

chia/util/service_groups.py

@@ -12,6 +12,7 @@ SERVICES_FOR_GROUP: dict[str, list[str]] = {
         "chia_wallet",
         "chia_data_layer",
         "chia_data_layer_http",
+        "chia_solver",
     ],
     "daemon": [],
     # TODO: should this be `data_layer`?
@@ -19,7 +20,7 @@ SERVICES_FOR_GROUP: dict[str, list[str]] = {
     "data_layer_http": ["chia_data_layer_http"],
     "node": ["chia_full_node"],
     "harvester": ["chia_harvester"],
-    "farmer": ["chia_harvester", "chia_farmer", "chia_full_node", "chia_wallet"],
+    "farmer": ["chia_harvester", "chia_farmer", "chia_full_node", "chia_wallet", "chia_solver"],
     "farmer-no-wallet": ["chia_harvester", "chia_farmer", "chia_full_node"],
     "farmer-only": ["chia_farmer"],
     "timelord": ["chia_timelord_launcher", "chia_timelord", "chia_full_node"],
@@ -31,6 +32,7 @@ SERVICES_FOR_GROUP: dict[str, list[str]] = {
     "crawler": ["chia_crawler"],
     "seeder": ["chia_crawler", "chia_seeder"],
     "seeder-only": ["chia_seeder"],
+    "solver": ["chia_solver"],
 }
 
 

chia/util/streamable.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 import dataclasses
+import functools
 import io
 import os
 import pprint
 import traceback
 from collections.abc import Collection
-from enum import Enum
+from enum import Enum, EnumMeta
 from typing import TYPE_CHECKING, Any, BinaryIO, Callable, ClassVar, Optional, TypeVar, Union, get_type_hints
 
 from chia_rs.sized_bytes import bytes32
@@ -130,6 +131,10 @@ def is_type_Dict(f_type: object) -> bool:
     return get_origin(f_type) is dict or f_type is dict
 
 
+def is_type_Enum(f_type: object) -> bool:
+    return type(f_type) is EnumMeta
+
+
 def convert_optional(convert_func: ConvertFunctionType, item: Any) -> Any:
     if item is None:
         return None
@@ -206,7 +211,7 @@ def streamable_from_dict(klass: type[_T_Streamable], item: Any) -> _T_Streamable
 
 
 def function_to_convert_one_item(
-    f_type: type[Any], json_parser: Optional[Callable[[object], Streamable]] = None
+    f_type: type[Any], json_parser: Optional[Callable[[object, type[object]], Streamable]] = None
 ) -> ConvertFunctionType:
     if is_type_SpecificOptional(f_type):
         convert_inner_func = function_to_convert_one_item(get_args(f_type)[0], json_parser)
@@ -230,8 +235,9 @@ def function_to_convert_one_item(
         return lambda mapping: convert_dict(key_converter, value_converter, mapping)  # type: ignore[arg-type]
     elif hasattr(f_type, "from_json_dict"):
         if json_parser is None:
-            json_parser = f_type.from_json_dict
-        return json_parser
+            return f_type.from_json_dict  # type: ignore[no-any-return]
+        else:
+            return functools.partial(json_parser, streamable_type=f_type)  # type: ignore[call-arg]
     elif issubclass(f_type, bytes):
         # Type is bytes, data is a hex string or bytes
         return lambda item: convert_byte_type(f_type, item)
@@ -303,13 +309,14 @@ def recurse_jsonify(
     elif isinstance(d, dict):
         new_dict = {}
         for name, val in d.items():
-            new_dict[name] = next_recursion_step(val, None, **next_recursion_env)
+            new_dict[next_recursion_step(name, None, **next_recursion_env)] = next_recursion_step(
+                val, None, **next_recursion_env
+            )
         return new_dict
-
+    elif isinstance(d, Enum):
+        return next_recursion_step(d.value, None, **next_recursion_env)
     elif issubclass(type(d), bytes):
         return f"0x{bytes(d).hex()}"
-    elif isinstance(d, Enum):
-        return d.name
     elif isinstance(d, bool):
         return d
     elif isinstance(d, int):
@@ -437,6 +444,10 @@ def function_to_parse_one_item(f_type: type[Any]) -> ParseFunctionType:
         key_parse_inner_type_f = function_to_parse_one_item(inner_types[0])
         value_parse_inner_type_f = function_to_parse_one_item(inner_types[1])
         return lambda f: parse_dict(f, key_parse_inner_type_f, value_parse_inner_type_f)
+    if is_type_Enum(f_type):
+        if not hasattr(f_type, "_streamable_proxy"):
+            raise UnsupportedType(f"Using Enum ({f_type}) in streamable requires a 'streamable_enum' wrapper.")
+        return lambda f: f_type(function_to_parse_one_item(f_type._streamable_proxy)(f))
     if f_type is str:
         return parse_str
     raise UnsupportedType(f"Type {f_type} does not have parse")
@@ -527,6 +538,13 @@ def function_to_stream_one_item(f_type: type[Any]) -> StreamFunctionType:
         key_stream_inner_type_func = function_to_stream_one_item(inner_types[0])
         value_stream_inner_type_func = function_to_stream_one_item(inner_types[1])
         return lambda item, f: stream_dict(key_stream_inner_type_func, value_stream_inner_type_func, item, f)
+    elif is_type_Enum(f_type):
+        if not hasattr(f_type, "_streamable_proxy"):
+            raise UnsupportedType(f"Using Enum ({f_type}) in streamable requires a 'streamable_enum' wrapper.")
+        return lambda item, f: function_to_stream_one_item(f_type._streamable_proxy)(
+            f_type._streamable_proxy(item.value),  # type: ignore[attr-defined]
+            f,
+        )
     elif f_type is str:
         return stream_str
     elif f_type is bool:
@@ -698,3 +716,15 @@ class UInt32Range(Streamable):
 class UInt64Range(Streamable):
     start: uint64 = uint64(0)
     stop: uint64 = uint64.MAXIMUM
+
+
+_T_Enum = TypeVar("_T_Enum", bound=EnumMeta)
+
+
+def streamable_enum(proxy: type[object]) -> Callable[[_T_Enum], _T_Enum]:
+    def streamable_enum_wrapper(cls: _T_Enum) -> _T_Enum:
+        setattr(cls, "_streamable_proxy", proxy)
+        setattr(cls, "_ignore_", ["_streamable_proxy"])
+        return cls
+
+    return streamable_enum_wrapper

chia/util/virtual_project_analysis.py

@@ -296,7 +296,7 @@ def parse_file_or_package(identifier: str) -> FileOrPackage:
         if "(" not in identifier:
             return File(Path(identifier))
         else:
-            return File(Path(identifier.split("(")[0].strip()))
+            return File(Path(identifier.split("(", maxsplit=1)[0].strip()))
 
     if ".py" not in identifier and identifier[0] == "(" and identifier[-1] == ")":
         return Package(identifier[1:-1])  # strip parens

chia/wallet/cat_wallet/cat_outer_puzzle.py

@@ -105,8 +105,11 @@ class CATOuterPuzzle:
             parent_coin: Coin = parent_spend.coin
             also = constructor.also()
             if also is not None:
-                solution = self._solve(also, solver, puzzle, solution)
-                puzzle = self._construct(also, puzzle)
+                constructed_solution = self._solve(also, solver, puzzle, solution)
+                constructed_puzzle = self._construct(also, puzzle)
+            else:
+                constructed_solution = solution
+                constructed_puzzle = puzzle
             args = match_cat_puzzle(uncurry_puzzle(parent_spend.puzzle_reveal))
             assert args is not None
             _, _, parent_inner_puzzle = args
@@ -114,8 +117,8 @@ class CATOuterPuzzle:
                 SpendableCAT(
                     coin,
                     tail_hash,
-                    puzzle,
-                    solution,
+                    constructed_puzzle,
+                    constructed_solution,
                     lineage_proof=LineageProof(
                         parent_coin.parent_coin_info, parent_inner_puzzle.get_tree_hash(), uint64(parent_coin.amount)
                     ),

chia/wallet/cat_wallet/cat_wallet.py

@@ -172,10 +172,12 @@ class CATWallet:
             raise ValueError("Internal Error, unable to generate new CAT coin")
         cat_pid: bytes32 = cat_coin.parent_coin_info
 
+        converted_ph = await self.convert_puzzle_hash(cat_coin.puzzle_hash)
         cat_record = TransactionRecord(
             confirmed_at_height=uint32(0),
-            created_at_time=uint64(int(time.time())),
-            to_puzzle_hash=(await self.convert_puzzle_hash(cat_coin.puzzle_hash)),
+            created_at_time=uint64(time.time()),
+            to_puzzle_hash=converted_ph,
+            to_address=self.wallet_state_manager.encode_puzzle_hash(converted_ph),
             amount=uint64(cat_coin.amount),
             fee_amount=fee,
             confirmed=False,
@@ -188,7 +190,7 @@ class CATWallet:
             trade_id=None,
             type=uint32(TransactionType.INCOMING_TX.value),
             name=spend_bundle.name(),
-            memos=[],
+            memos={},
             valid_times=ConditionValidTimes(),
         )
         async with action_scope.use() as interface:
@@ -256,8 +258,11 @@ class CATWallet:
         puzzle_driver: PuzzleInfo,
         name: Optional[str] = None,
         # We're hinting this as Any for mypy by should explore adding this to the wallet protocol and hinting properly
-        potential_subclasses: dict[AssetType, Any] = {},
+        potential_subclasses: Optional[dict[AssetType, Any]] = None,
     ) -> Any:
+        if potential_subclasses is None:
+            potential_subclasses = {}
+
         next_layer: Optional[PuzzleInfo] = puzzle_driver.also()
         if next_layer is not None:
             if AssetType(next_layer.type()) in potential_subclasses:
@@ -464,7 +469,7 @@ class CATWallet:
             for coin in record.additions:
                 hint_dict = {
                     coin_id: bytes32(memos[0])
-                    for coin_id, memos in record.memos
+                    for coin_id, memos in record.memos.items()
                     if len(memos) > 0 and len(memos[0]) == 32
                 }
                 if await self.wallet_state_manager.does_coin_belong_to_wallet(coin, self.id(), hint_dict=hint_dict):
@@ -791,8 +796,9 @@ class CATWallet:
             interface.side_effects.transactions.append(
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
-                    created_at_time=uint64(int(time.time())),
+                    created_at_time=uint64(time.time()),
                     to_puzzle_hash=puzzle_hashes[0],
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(puzzle_hashes[0]),
                     amount=uint64(payment_sum),
                     fee_amount=fee,
                     confirmed=False,
@@ -805,7 +811,7 @@ class CATWallet:
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=list(compute_memos(spend_bundle).items()),
+                    memos=compute_memos(spend_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
             )

chia/wallet/cat_wallet/r_cat_wallet.py

@@ -139,8 +139,11 @@ class RCATWallet(CATWallet):
         puzzle_driver: PuzzleInfo,
         name: Optional[str] = None,
         # We're hinting this as Any for mypy by should explore adding this to the wallet protocol and hinting properly
-        potential_subclasses: dict[AssetType, Any] = {},
+        potential_subclasses: Optional[dict[AssetType, Any]] = None,
     ) -> Any:
+        if potential_subclasses is None:
+            potential_subclasses = {}
+
         rev_layer: Optional[PuzzleInfo] = puzzle_driver.also()
         if rev_layer is None:
             raise ValueError("create_from_puzzle_info called on RCATWallet with a non R-CAT puzzle driver")

chia/wallet/conditions.py

@@ -1472,9 +1472,7 @@ def parse_timelock_info(conditions: Iterable[Condition]) -> ConditionValidTimes:
         elif isinstance(condition, Timelock):
             timelock = condition
         else:
-            # Something about python 3.9 makes this be not covered but on 3.10+ it is covered
-            # https://github.com/nedbat/coveragepy/issues/1530
-            continue  # pragma: no cover
+            continue
 
         properties_left = properties.copy()
         min_not_max: bool = True