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

chia/plotting/check_plots.py

@@ -3,16 +3,20 @@ from __future__ import annotations
 import concurrent.futures
 import logging
 from collections import Counter
+from collections.abc import Sequence
 from pathlib import Path
 from threading import Lock
-from time import sleep, time
-from typing import Optional
+from time import monotonic, sleep
+from typing import Optional, Union
 
 from chia_rs import G1Element
-from chia_rs.sized_ints import uint32
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint32
 from chiapos import Verifier
 
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.plotting.manager import PlotManager
+from chia.plotting.prover import PlotVersion
 from chia.plotting.util import (
     PlotInfo,
     PlotRefreshEvents,
@@ -22,6 +26,10 @@ from chia.plotting.util import (
     get_plot_filenames,
     parse_plot_info,
 )
+from chia.types.blockchain_format.proof_of_space import (
+    quality_for_partial_proof,
+    solve_proof,
+)
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import load_config
 from chia.util.cpu import available_logical_cores
@@ -133,14 +141,16 @@ def check_plots(
         log.info("")
         log.info("")
         log.info(f"Starting to test each plot with {num} challenges each\n")
-    total_good_plots: Counter[str] = Counter()
+    total_good_plots_v1: Counter[uint8] = Counter()
+    total_good_plots_v2: Counter[uint8] = Counter()
     total_size = 0
     bad_plots_list: list[Path] = []
 
     with plot_manager:
 
         def process_plot(plot_path: Path, plot_info: PlotInfo, num_start: int, num_end: int, lock: Lock) -> None:
-            nonlocal total_good_plots
+            nonlocal total_good_plots_v1
+            nonlocal total_good_plots_v2
             nonlocal total_size
             nonlocal bad_plots_list
 
@@ -166,48 +176,26 @@ def check_plots(
 
             total_proofs = 0
             caught_exception: bool = False
+            version = pr.get_version()
             for i in range(num_start, num_end):
                 challenge = std_hash(i.to_bytes(32, "big"))
+                # these are either qualities (v1) or partial proofs (v2)
+                proofs: Sequence[Union[bytes32, bytes]]
                 # Some plot errors cause get_qualities_for_challenge to throw a RuntimeError
                 try:
-                    quality_start_time = int(round(time() * 1000))
-                    for index, quality_str in enumerate(pr.get_qualities_for_challenge(challenge)):
-                        quality_spent_time = int(round(time() * 1000)) - quality_start_time
-                        if quality_spent_time > 8000:
-                            log.warning(
-                                f"\tLooking up qualities took: {quality_spent_time} ms. This should be below 8 seconds "
-                                f"to minimize risk of losing rewards. Filepath: {plot_path}"
-                            )
-                        else:
-                            log.info(f"\tLooking up qualities took: {quality_spent_time} ms. Filepath: {plot_path}")
-
-                        # Other plot errors cause get_full_proof or validate_proof to throw an AssertionError
-                        try:
-                            proof_start_time = int(round(time() * 1000))
-                            proof = pr.get_full_proof(challenge, index, parallel_read)
-                            proof_spent_time = int(round(time() * 1000)) - proof_start_time
-                            if proof_spent_time > 15000:
-                                log.warning(
-                                    f"\tFinding proof took: {proof_spent_time} ms. This should be below 15 seconds "
-                                    f"to minimize risk of losing rewards. Filepath: {plot_path}"
-                                )
-                            else:
-                                log.info(f"\tFinding proof took: {proof_spent_time} ms. Filepath: {plot_path}")
-
-                            ver_quality_str = v.validate_proof(pr.get_id(), pr.get_size(), challenge, proof)
-                            if quality_str == ver_quality_str:
-                                total_proofs += 1
-                            else:
-                                log.warning(
-                                    f"\tQuality doesn't match with proof. Filepath: {plot_path} "
-                                    "This can occasionally happen with a compressed plot."
-                                )
-                        except AssertionError as e:
-                            log.error(
-                                f"{type(e)}: {e} error in proving/verifying for plot {plot_path}. Filepath: {plot_path}"
-                            )
-                            caught_exception = True
-                        quality_start_time = int(round(time() * 1000))
+                    quality_start_time = round(monotonic() * 1000)
+                    if version == PlotVersion.V1:
+                        proofs = pr.get_qualities_for_challenge(challenge)
+                    else:
+                        proofs = pr.get_partial_proofs_for_challenge(challenge, DEFAULT_CONSTANTS.PLOT_STRENGTH_INITIAL)
+                    quality_spent_time = round(monotonic() * 1000) - quality_start_time
+                    if quality_spent_time > 8000:
+                        log.warning(
+                            f"\tLooking up qualities took: {quality_spent_time} ms. This should be below 8 seconds "
+                            f"to minimize risk of losing rewards. Filepath: {plot_path}"
+                        )
+                    else:
+                        log.info(f"\tLooking up qualities took: {quality_spent_time} ms. Filepath: {plot_path}")
                 except KeyboardInterrupt:
                     log.warning("Interrupted, closing")
                     return
@@ -221,9 +209,46 @@ def check_plots(
                     else:
                         log.error(f"{type(e)}: {e} error in getting challenge qualities for plot {plot_path}")
                         caught_exception = True
+                        continue
                 except Exception as e:
                     log.error(f"{type(e)}: {e} error in getting challenge qualities for plot {plot_path}")
                     caught_exception = True
+                    break
+
+                for index, proof in enumerate(proofs):
+                    # Other plot errors cause get_full_proof or validate_proof to throw an AssertionError
+                    try:
+                        proof_start_time = round(monotonic() * 1000)
+                        if version == PlotVersion.V1:
+                            quality_str = bytes32(proof)
+                            full_proof = pr.get_full_proof(challenge, index, parallel_read)
+                            proof_spent_time = round(monotonic() * 1000) - proof_start_time
+                        else:
+                            quality_str = quality_for_partial_proof(proof, challenge)
+                            proof_spent_time = round(monotonic() * 1000) - proof_start_time
+                            full_proof = solve_proof(proof)
+
+                        if proof_spent_time > 15000:
+                            log.warning(
+                                f"\tFinding proof took: {proof_spent_time} ms. This should be below 15 seconds "
+                                f"to minimize risk of losing rewards. Filepath: {plot_path}"
+                            )
+                        else:
+                            log.info(f"\tFinding proof took: {proof_spent_time} ms. Filepath: {plot_path}")
+
+                        ver_quality_str = v.validate_proof(pr.get_id(), pr.get_size().size_v1, challenge, full_proof)
+                        if quality_str == ver_quality_str:
+                            total_proofs += 1
+                        else:
+                            log.warning(
+                                f"\tQuality doesn't match with proof. Filepath: {plot_path} "
+                                "This can occasionally happen with a compressed plot."
+                            )
+                    except AssertionError as e:
+                        log.error(
+                            f"{type(e)}: {e} error in proving/verifying for plot {plot_path}. Filepath: {plot_path}"
+                        )
+                        caught_exception = True
                 if caught_exception is True:
                     break
 
@@ -232,8 +257,16 @@ def check_plots(
                     f"\tProofs {total_proofs} / {challenges}, {round(total_proofs / float(challenges), 4)}. "
                     f"Filepath: {plot_path}"
                 )
-                total_good_plots[pr.get_size()] += 1
-                total_size += plot_path.stat().st_size
+                version_and_size = pr.get_size()
+                if version_and_size.size_v1 is not None:
+                    k = version_and_size.size_v1
+                    total_good_plots_v1[k] += 1
+                    total_size += plot_path.stat().st_size
+                else:
+                    assert version_and_size.size_v2 is not None
+                    k = version_and_size.size_v2
+                    total_good_plots_v2[k] += 1
+                    total_size += plot_path.stat().st_size
             else:
                 log.error(
                     f"\tProofs {total_proofs} / {challenges}, {round(total_proofs / float(challenges), 4)} "
@@ -255,10 +288,12 @@ def check_plots(
     log.info("")
     log.info("")
     log.info("Summary")
-    total_plots: int = sum(list(total_good_plots.values()))
+    total_plots: int = sum(list(total_good_plots_v1.values()) + list(total_good_plots_v2.values()))
     log.info(f"Found {total_plots} valid plots, total size {total_size / (1024 * 1024 * 1024 * 1024):.5f} TiB")
-    for k, count in sorted(dict(total_good_plots).items()):
-        log.info(f"{count} plots of size {k}")
+    for k, count in sorted(dict(total_good_plots_v1).items()):
+        log.info(f"{count} v1 plots of size {k}")
+    for k, count in sorted(dict(total_good_plots_v2).items()):
+        log.info(f"{count} v2 plots of size {k}")
     grand_total_bad = len(bad_plots_list) + len(plot_manager.failed_to_open_filenames)
     if grand_total_bad > 0:
         log.warning(f"{grand_total_bad} invalid plots found:")

chia/plotting/create_plots.py

@@ -83,10 +83,9 @@ class PlotKeysResolver:
                 if self.pool_contract_address is not None:
                     raise RuntimeError("Choose one of pool_contract_address and pool_public_key")
                 pool_public_key = G1Element.from_bytes(bytes.fromhex(self.pool_public_key))
-            else:
-                if self.pool_contract_address is None:
-                    # If nothing is set, farms to the provided key (or the first key)
-                    pool_public_key = await self.get_pool_public_key(keychain_proxy)
+            elif self.pool_contract_address is None:
+                # If nothing is set, farms to the provided key (or the first key)
+                pool_public_key = await self.get_pool_public_key(keychain_proxy)
 
             self.resolved_keys = PlotKeys(farmer_public_key, pool_public_key, self.pool_contract_address)
         finally:

chia/plotting/manager.py

@@ -9,10 +9,11 @@ from pathlib import Path
 from typing import Any, Callable, Optional
 
 from chia_rs import G1Element
-from chiapos import DiskProver, decompressor_context_queue
+from chiapos import decompressor_context_queue
 
 from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size
 from chia.plotting.cache import Cache, CacheEntry
+from chia.plotting.prover import get_prover_from_file
 from chia.plotting.util import (
     HarvestingMode,
     PlotInfo,
@@ -323,7 +324,7 @@ class PlotManager:
                 cache_entry = self.cache.get(file_path)
                 cache_hit = cache_entry is not None
                 if not cache_hit:
-                    prover = DiskProver(str(file_path))
+                    prover = get_prover_from_file(str(file_path))
 
                     log.debug(f"process_file {file_path!s}")
 
@@ -332,18 +333,22 @@ class PlotManager:
                     # TODO: consider checking if the file was just written to (which would mean that the file is still
                     # being copied). A segfault might happen in this edge case.
 
+                    k = prover.get_size()
                     level = prover.get_compression_level()
-                    if level == 0:
-                        if prover.get_size() >= 30 and stat_info.st_size < 0.98 * expected_size:
-                            log.warning(
-                                f"Not farming plot {file_path}. "
-                                f"Size is {stat_info.st_size / (1024**3)} GiB, "
-                                f"but expected at least: {expected_size / (1024**3)} GiB. "
-                                "We assume the file is being copied."
-                            )
-                            return None
-
-                    cache_entry = CacheEntry.from_disk_prover(prover)
+                    if (
+                        level == 0
+                        and stat_info.st_size < 0.98 * expected_size
+                        and ((k.size_v1 is not None and k.size_v1 >= 30) or (k.size_v2 is not None and k.size_v2 >= 28))
+                    ):
+                        log.warning(
+                            f"Not farming plot {file_path}. "
+                            f"Size is {stat_info.st_size / (1024**3)} GiB, "
+                            f"but expected at least: {expected_size / (1024**3)} GiB. "
+                            "We assume the file is being copied."
+                        )
+                        return None
+
+                    cache_entry = CacheEntry.from_prover(prover)
                     self.cache.update(file_path, cache_entry)
 
                 assert cache_entry is not None

chia/plotting/prover.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import TYPE_CHECKING, ClassVar, Protocol, cast
+
+from chia_rs import PlotSize
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8
+from chiapos import DiskProver
+
+if TYPE_CHECKING:
+    from chiapos import DiskProver
+
+
+class PlotVersion(IntEnum):
+    """Enum for plot format versions"""
+
+    V1 = 1
+    V2 = 2
+
+
+class ProverProtocol(Protocol):
+    def get_filename(self) -> str: ...
+    def get_size(self) -> PlotSize: ...
+    def get_memo(self) -> bytes: ...
+    def get_compression_level(self) -> uint8: ...
+    def get_version(self) -> PlotVersion: ...
+    def __bytes__(self) -> bytes: ...
+    def get_id(self) -> bytes32: ...
+    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]: ...
+
+    # this is only supported by v2 plots
+    def get_partial_proofs_for_challenge(self, challenge: bytes32, required_plot_strength: uint8) -> list[bytes]: ...
+
+    # this is only supported by v1 plots. v2 plots first get the partial proof
+    # and turn it into a full proof by calling solve_proof(), or pass it to the solver service
+    def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes: ...
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> ProverProtocol: ...
+
+
+class V2Prover:
+    """Placeholder for future V2 plot format support"""
+
+    if TYPE_CHECKING:
+        _protocol_check: ClassVar[ProverProtocol] = cast("V2Prover", None)
+
+    def __init__(self, filename: str):
+        self._filename = filename
+
+    def get_filename(self) -> str:
+        return str(self._filename)
+
+    def get_size(self) -> PlotSize:
+        # TODO: todo_v2_plots get k size from plot
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+    def get_memo(self) -> bytes:
+        # TODO: todo_v2_plots
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+    def get_compression_level(self) -> uint8:
+        # v2 plots are never compressed
+        return uint8(0)
+
+    def get_version(self) -> PlotVersion:
+        return PlotVersion.V2
+
+    def __bytes__(self) -> bytes:
+        # TODO: todo_v2_plots Implement prover serialization for caching
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+    def get_id(self) -> bytes32:
+        # TODO: Extract plot ID from V2 plot file
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]:
+        raise AssertionError("V2 plot format does not support qualities directly, use partial proofs")
+
+    def get_partial_proofs_for_challenge(self, challenge: bytes, required_plot_strength: uint8) -> list[bytes]:
+        # TODO: todo_v2_plots Implement plot partial proof lookup
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+    def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes:
+        raise AssertionError("V2 plot format require solver to get full proof")
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> V2Prover:
+        # TODO: todo_v2_plots Implement prover deserialization from cache
+        raise NotImplementedError("V2 plot format is not yet implemented")
+
+
+class V1Prover:
+    """Wrapper for existing DiskProver to implement ProverProtocol"""
+
+    if TYPE_CHECKING:
+        _protocol_check: ClassVar[ProverProtocol] = cast("V1Prover", None)
+
+    def __init__(self, disk_prover: DiskProver) -> None:
+        self._disk_prover = disk_prover
+
+    def get_filename(self) -> str:
+        return str(self._disk_prover.get_filename())
+
+    def get_size(self) -> PlotSize:
+        return PlotSize.make_v1(uint8(self._disk_prover.get_size()))
+
+    def get_memo(self) -> bytes:
+        return bytes(self._disk_prover.get_memo())
+
+    def get_compression_level(self) -> uint8:
+        return uint8(self._disk_prover.get_compression_level())
+
+    def get_version(self) -> PlotVersion:
+        return PlotVersion.V1
+
+    def __bytes__(self) -> bytes:
+        return bytes(self._disk_prover)
+
+    def get_id(self) -> bytes32:
+        return bytes32(self._disk_prover.get_id())
+
+    def get_qualities_for_challenge(self, challenge: bytes32) -> list[bytes32]:
+        return [bytes32(quality) for quality in self._disk_prover.get_qualities_for_challenge(challenge)]
+
+    def get_partial_proofs_for_challenge(self, challenge: bytes32, required_plot_strength: uint8) -> list[bytes]:
+        raise AssertionError("V1 plot format doesn't use partial proofs")
+
+    def get_full_proof(self, challenge: bytes32, index: int, parallel_read: bool = True) -> bytes:
+        return bytes(self._disk_prover.get_full_proof(challenge, index, parallel_read))
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> V1Prover:
+        return cls(DiskProver.from_bytes(data))
+
+
+def get_prover_from_bytes(filename: str, prover_data: bytes) -> ProverProtocol:
+    if filename.endswith(".plot2"):
+        return V2Prover.from_bytes(prover_data)
+    elif filename.endswith(".plot"):
+        return V1Prover(DiskProver.from_bytes(prover_data))
+    else:
+        raise ValueError(f"Unsupported plot file: {filename}")
+
+
+def get_prover_from_file(filename: str) -> ProverProtocol:
+    if filename.endswith(".plot2"):
+        return V2Prover(filename)
+    elif filename.endswith(".plot"):
+        return V1Prover(DiskProver(filename))
+    else:
+        raise ValueError(f"Unsupported plot file: {filename}")

chia/plotting/util.py

@@ -4,12 +4,14 @@ import logging
 from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+if TYPE_CHECKING:
+    from chia.plotting.prover import ProverProtocol
 
 from chia_rs import G1Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
-from chiapos import DiskProver
 from typing_extensions import final
 
 from chia.util.config import load_config, lock_and_load_config, save_config
@@ -39,7 +41,7 @@ class PlotsRefreshParameter(Streamable):
 
 @dataclass
 class PlotInfo:
-    prover: DiskProver
+    prover: ProverProtocol
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
     plot_public_key: G1Element
@@ -233,16 +235,22 @@ def get_filenames(directory: Path, recursive: bool, follow_links: bool) -> list[
         if follow_links and recursive:
             import glob
 
-            files = glob.glob(str(directory / "**" / "*.plot"), recursive=True)
-            for file in files:
+            v1_file_strs = glob.glob(str(directory / "**" / "*.plot"), recursive=True)
+            v2_file_strs = glob.glob(str(directory / "**" / "*.plot2"), recursive=True)
+
+            for file in v1_file_strs + v2_file_strs:
                 filepath = Path(file).resolve()
                 if filepath.is_file() and not filepath.name.startswith("._"):
                     all_files.append(filepath)
         else:
             glob_function = directory.rglob if recursive else directory.glob
-            all_files = [
+            v1_files: list[Path] = [
                 child for child in glob_function("*.plot") if child.is_file() and not child.name.startswith("._")
             ]
+            v2_files: list[Path] = [
+                child for child in glob_function("*.plot2") if child.is_file() and not child.name.startswith("._")
+            ]
+            all_files = v1_files + v2_files
         log.debug(f"get_filenames: {len(all_files)} files found in {directory}, recursive: {recursive}")
     except Exception as e:
         log.warning(f"Error reading directory {directory} {e}")

chia/pools/pool_wallet.py

@@ -525,8 +525,9 @@ class PoolWallet:
             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=new_full_puzzle.get_tree_hash(),
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(new_full_puzzle.get_tree_hash()),
                     amount=uint64(1),
                     fee_amount=fee,
                     confirmed=False,
@@ -537,7 +538,7 @@ class PoolWallet:
                     wallet_id=self.id(),
                     sent_to=[],
                     trade_id=None,
-                    memos=[],
+                    memos={},
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=unsigned_spend_bundle.name(),
                     valid_times=ConditionValidTimes(),
@@ -792,7 +793,7 @@ class PoolWallet:
                 ),
             )
 
-        current_time = uint64(int(time.time()))
+        current_time = uint64(time.time())
         # The claim spend, minus the fee amount from the main wallet
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
@@ -800,6 +801,7 @@ class PoolWallet:
                     confirmed_at_height=uint32(0),
                     created_at_time=current_time,
                     to_puzzle_hash=current_state.current.target_puzzle_hash,
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(current_state.current.target_puzzle_hash),
                     amount=uint64(total_amount),
                     fee_amount=fee,  # This will not be double counted in self.standard_wallet
                     confirmed=False,
@@ -809,7 +811,7 @@ class PoolWallet:
                     removals=claim_spend.removals(),
                     wallet_id=uint32(self.wallet_id),
                     sent_to=[],
-                    memos=[],
+                    memos={},
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=claim_spend.name(),

chia/protocols/harvester_protocol.py

@@ -77,6 +77,20 @@ class NewProofOfSpace(Streamable):
     fee_info: Optional[ProofOfSpaceFeeInfo]
 
 
+@streamable
+@dataclass(frozen=True)
+class PartialProofsData(Streamable):
+    challenge_hash: bytes32
+    sp_hash: bytes32
+    plot_identifier: str
+    partial_proofs: list[bytes]  # 16 * k bits blobs instead of 32-byte quality strings
+    signage_point_index: uint8
+    plot_size: uint8
+    pool_public_key: Optional[G1Element]
+    pool_contract_puzzle_hash: Optional[bytes32]
+    plot_public_key: G1Element
+
+
 # Source data corresponding to the hash that is sent to the Harvester for signing
 class SigningDataKind(IntEnum):
     FOLIAGE_BLOCK_DATA = 1

chia/protocols/outbound_message.py

@@ -18,6 +18,7 @@ class NodeType(IntEnum):
     INTRODUCER = 5
     WALLET = 6
     DATA_LAYER = 7
+    SOLVER = 8
 
 
 @streamable

chia/protocols/pool_protocol.py

@@ -168,7 +168,7 @@ class ErrorResponse(Streamable):
 
 # Get the current authentication token according to "Farmer authentication" in SPECIFICATION.md
 def get_current_authentication_token(timeout: uint8) -> uint64:
-    return uint64(int(int(time.time() / 60) / timeout))
+    return uint64(int(time.time() / 60) / timeout)
 
 
 # Validate a given authentication token against our local time

chia/protocols/protocol_message_types.py

@@ -13,6 +13,7 @@ class ProtocolMessageTypes(Enum):
     new_proof_of_space = 5
     request_signatures = 6
     respond_signatures = 7
+    partial_proofs = 110
 
     # Farmer protocol (farmer <-> full_node)
     new_signage_point = 8
@@ -136,4 +137,10 @@ class ProtocolMessageTypes(Enum):
     request_cost_info = 106
     respond_cost_info = 107
 
+    # new farmer protocol messages
+    solution_response = 108
+
+    # solver protocol
+    solve = 109
+
     error = 255

chia/protocols/shared_protocol.py

@@ -17,6 +17,7 @@ protocol_version = {
     NodeType.INTRODUCER: "0.0.36",
     NodeType.WALLET: "0.0.38",
     NodeType.DATA_LAYER: "0.0.36",
+    NodeType.SOLVER: "0.0.37",
 }
 
 """
@@ -65,6 +66,7 @@ default_capabilities = {
     NodeType.INTRODUCER: _capabilities,
     NodeType.WALLET: _capabilities,
     NodeType.DATA_LAYER: _capabilities,
+    NodeType.SOLVER: _capabilities,
 }
 
 

chia/protocols/solver_protocol.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclass(frozen=True)
+class SolverInfo(Streamable):
+    partial_proof: bytes  # 16 * k bits blob, k (plot size) can be derived from this
+
+
+@streamable
+@dataclass(frozen=True)
+class SolverResponse(Streamable):
+    partial_proof: bytes
+    proof: bytes

chia/rpc/rpc_server.py

@@ -292,7 +292,7 @@ class RpcServer(Generic[_T_RpcApiProtocol]):
     async def open_connection(self, request: dict[str, Any]) -> EndpointResult:
         host = request["host"]
         port = request["port"]
-        target_node: PeerInfo = PeerInfo(await resolve(host, prefer_ipv6=self.prefer_ipv6), uint16(int(port)))
+        target_node: PeerInfo = PeerInfo(await resolve(host, prefer_ipv6=self.prefer_ipv6), uint16(port))
         on_connect = None
         if hasattr(self.rpc_api.service, "on_connect"):
             on_connect = self.rpc_api.service.on_connect

chia/seeder/crawl_store.py

@@ -195,11 +195,10 @@ class CrawlStore:
             counter += 1
             if reliability.ignore_till < now and reliability.ban_till < now:
                 add = True
-            else:
-                if reliability.ban_till >= now:
-                    self.banned_peers += 1
-                elif reliability.ignore_till >= now:
-                    self.ignored_peers += 1
+            elif reliability.ban_till >= now:
+                self.banned_peers += 1
+            elif reliability.ignore_till >= now:
+                self.ignored_peers += 1
             record = self.host_to_records[peer_id]
             if record.last_try_timestamp == 0 and record.connected_timestamp == 0:
                 add = True
@@ -342,9 +341,6 @@ class CrawlStore:
         handshake = {}
 
         for host, record in self.host_to_records.items():
-            if host not in self.host_to_records:
-                continue
-            record = self.host_to_records[host]
             if record.version == "undefined":
                 continue
             if record.handshake_time < time.time() - 5 * 24 * 3600: