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

chia/solver/solver.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from collections.abc import AsyncIterator
+from concurrent.futures.thread import ThreadPoolExecutor
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia_rs import ConsensusConstants
+
+from chia.protocols.outbound_message import NodeType
+from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.blockchain_format.proof_of_space import solve_proof
+
+log = logging.getLogger(__name__)
+
+
+class Solver:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcServiceProtocol
+
+        _protocol_check: ClassVar[RpcServiceProtocol] = cast("Solver", None)
+
+    root_path: Path
+    _server: Optional[ChiaServer]
+    _shut_down: bool
+    started: bool = False
+    executor: ThreadPoolExecutor
+    state_changed_callback: Optional[StateChangedProtocol] = None
+    constants: ConsensusConstants
+    event_loop: asyncio.events.AbstractEventLoop
+
+    @property
+    def server(self) -> ChiaServer:
+        if self._server is None:
+            raise RuntimeError("server not assigned")
+
+        return self._server
+
+    def __init__(self, root_path: Path, config: dict[str, Any], constants: ConsensusConstants):
+        self.log = log
+        self.root_path = root_path
+        self.config = config
+        self._shut_down = False
+        num_threads = config["num_threads"]
+        self.log.info(f"Initializing solver with {num_threads} threads")
+        self.executor = ThreadPoolExecutor(max_workers=num_threads, thread_name_prefix="solver-")
+        self._server = None
+        self.constants = constants
+        self.state_changed_callback: Optional[StateChangedProtocol] = None
+        self.log.info("Solver initialization complete")
+
+    @contextlib.asynccontextmanager
+    async def manage(self) -> AsyncIterator[None]:
+        try:
+            self.log.info("Starting solver service")
+            self.started = True
+            self.log.info("Solver service started successfully")
+            yield
+        finally:
+            self.log.info("Shutting down solver service")
+            self._shut_down = True
+            self.executor.shutdown(wait=True)
+            self.log.info("Solver service shutdown complete")
+
+    def solve(self, partial_proof: bytes) -> Optional[bytes]:
+        self.log.debug(f"Solve request: partial={partial_proof.hex()}")
+        try:
+            return solve_proof(partial_proof)
+        except Exception:
+            self.log.exception("solve_proof()")
+        return None
+
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+        return default_get_connections(server=self.server, request_node_type=request_node_type)
+
+    async def on_connect(self, connection: WSChiaConnection) -> None:
+        if self.server.is_trusted_peer(connection, self.config.get("trusted_peers", {})):
+            self.log.info(f"Accepting connection from {connection.get_peer_logging()}")
+            return
+        if not self.config.get("trusted_peers_only", True):
+            self.log.info(
+                f"trusted peers check disabled, Accepting connection from untrusted {connection.get_peer_logging()}"
+            )
+            return
+        self.log.warning(f"Rejecting untrusted connection from {connection.get_peer_logging()}")
+        await connection.close()
+
+    async def on_disconnect(self, connection: WSChiaConnection) -> None:
+        self.log.info(f"peer disconnected {connection.get_peer_logging()}")
+
+    def set_server(self, server: ChiaServer) -> None:
+        self._server = server
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        self.state_changed_callback = callback

chia/solver/solver_api.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
+
+from chia.protocols.outbound_message import Message, make_msg
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.solver_protocol import SolverInfo, SolverResponse
+from chia.server.api_protocol import ApiMetadata
+from chia.solver.solver import Solver
+
+
+class SolverAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("SolverAPI", None)
+
+    log: logging.Logger
+    solver: Solver
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def __init__(self, solver: Solver) -> None:
+        self.log = logging.getLogger(__name__)
+        self.solver = solver
+
+    def ready(self) -> bool:
+        return self.solver.started
+
+    @metadata.request(peer_required=False, reply_types=[ProtocolMessageTypes.solution_response])
+    async def solve(
+        self,
+        request: SolverInfo,
+    ) -> Optional[Message]:
+        """
+        Solve a V2 plot partial proof to get the full proof of space.
+        This is called by the farmer when it receives V2 parital proofs from harvester.
+        """
+        if not self.solver.started:
+            self.log.error("Solver is not started")
+            return None
+
+        self.log.debug(f"Solving partial {request.partial_proof.hex()}")
+
+        try:
+            proof = self.solver.solve(request.partial_proof)
+            if proof is None:
+                self.log.warning(f"Solver returned no proof for parital {request.partial_proof.hex()}")
+                return None
+
+            self.log.debug(f"Successfully solved partial proof, returning {len(proof)} byte proof")
+            return make_msg(
+                ProtocolMessageTypes.solution_response,
+                SolverResponse(proof=proof, partial_proof=request.partial_proof),
+            )
+
+        except Exception as e:
+            self.log.error(f"Error solving parital {request.partial_proof.hex()}: {e}")
+            return None

chia/solver/solver_rpc_api.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia.rpc.rpc_server import Endpoint, EndpointResult
+from chia.solver.solver import Solver
+from chia.util.ws_message import WsRpcMessage
+
+
+class SolverRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("SolverRpcApi", None)
+
+    def __init__(self, solver: Solver):
+        self.service = solver
+        self.service_name = "chia_solver"
+
+    def get_routes(self) -> dict[str, Endpoint]:
+        return {
+            "/get_state": self.get_state,
+        }
+
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+        return []
+
+    async def get_state(self, _: dict[str, Any]) -> EndpointResult:
+        return {
+            "started": self.service.started,
+        }

chia/solver/solver_rpc_client.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+from chia.rpc.rpc_client import RpcClient
+
+
+class SolverRpcClient(RpcClient):
+    """
+    Client to Chia RPC, connects to a local solver. Uses HTTP/JSON, and converts back from
+    JSON into native python objects before returning. All api calls use POST requests.
+    """
+
+    async def get_state(self) -> dict[str, Any]:
+        """Get solver state."""
+        return await self.fetch("get_state", {})

chia/solver/solver_service.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from chia.server.start_service import Service
+from chia.solver.solver import Solver
+from chia.solver.solver_api import SolverAPI
+from chia.solver.solver_rpc_api import SolverRpcApi
+
+SolverService = Service[Solver, SolverAPI, SolverRpcApi]

chia/solver/start_solver.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from multiprocessing import freeze_support
+from typing import Any, Optional
+
+from chia_rs import ConsensusConstants
+from chia_rs.sized_ints import uint16
+
+from chia.apis import ApiProtocolRegistry
+from chia.consensus.constants import replace_str_to_bytes
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.protocols.outbound_message import NodeType
+from chia.server.signal_handlers import SignalHandlers
+from chia.server.start_service import Service, async_run
+from chia.solver.solver import Solver
+from chia.solver.solver_api import SolverAPI
+from chia.solver.solver_rpc_api import SolverRpcApi
+from chia.solver.solver_service import SolverService
+from chia.util.chia_logging import initialize_service_logging
+from chia.util.config import load_config, load_config_cli
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
+
+# See: https://bugs.python.org/issue29288
+"".encode("idna")
+
+SERVICE_NAME = "solver"
+
+
+def create_solver_service(
+    root_path: pathlib.Path,
+    config: dict[str, Any],
+    consensus_constants: ConsensusConstants,
+    connect_to_daemon: bool = True,
+    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+) -> SolverService:
+    service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+    upnp_list = []
+    if service_config["enable_upnp"]:
+        upnp_list = [service_config["port"]]
+
+    node = Solver(root_path, service_config, consensus_constants)
+    peer_api = SolverAPI(node)
+    network_id = service_config["selected_network"]
+
+    rpc_info = None
+    if service_config.get("start_rpc_server", True):
+        rpc_info = (SolverRpcApi, service_config["rpc_port"])
+
+    return Service(
+        root_path=root_path,
+        config=config,
+        node=node,
+        peer_api=peer_api,
+        node_type=NodeType.SOLVER,
+        advertised_port=service_config["port"],
+        service_name=SERVICE_NAME,
+        upnp_ports=upnp_list,
+        on_connect_callback=node.on_connect,
+        network_id=network_id,
+        rpc_info=rpc_info,
+        connect_to_daemon=connect_to_daemon,
+        override_capabilities=override_capabilities,
+        class_for_type=ApiProtocolRegistry,
+    )
+
+
+async def async_main(service_config: dict[str, Any], root_path: pathlib.Path) -> int:
+    config = load_config(root_path, "config.yaml", fill_missing_services=True)
+    config[SERVICE_NAME] = service_config
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
+    updated_constants = replace_str_to_bytes(DEFAULT_CONSTANTS, **overrides)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_solver_service(root_path, config, updated_constants)
+    async with SignalHandlers.manage() as signal_handlers:
+        await service.setup_process_global_state(signal_handlers=signal_handlers)
+        await service.run()
+
+    return 0
+
+
+def main() -> int:
+    freeze_support()
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
+        return async_run(coro=async_main(service_config, root_path=root_path))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{mozilla-ca → chia/ssl}/cacert.pem

@@ -1,28 +1,3 @@
-##
-## Bundle of CA Root Certificates
-##
-## Certificate data from Mozilla as of: Tue May 20 03:12:02 2025 GMT
-##
-## Find updated versions here: https://curl.se/docs/caextract.html
-##
-## This is a bundle of X.509 certificates of public Certificate Authorities
-## (CA). These were automatically extracted from Mozilla's root certificates
-## file (certdata.txt).  This file can be found in the mozilla source tree:
-## https://raw.githubusercontent.com/mozilla-firefox/firefox/refs/heads/release/security/nss/lib/ckfw/builtins/certdata.txt
-##
-## It contains the certificates in PEM format and therefore
-## can be directly used with curl / libcurl / php_curl, or with
-## an Apache+mod_ssl webserver for SSL client authentication.
-## Just configure this file as the SSLCACertificateFile.
-##
-## Conversion done with mk-ca-bundle.pl version 1.29.
-## SHA256: 8944ec6b572b577daee4fc681a425881f841ec2660e4cb5f0eee727f84620697
-##
-
-
-Entrust Root Certification Authority
-====================================
------BEGIN CERTIFICATE-----
 MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMCVVMxFjAUBgNV
 BAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0Lm5ldC9DUFMgaXMgaW5jb3Jw
 b3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMWKGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsG
@@ -44,11 +19,9 @@ Y/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6ZuaAGAT/3B+XxFNSRuzFVJ7yVTa
 v52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTS
 W3iDVuycNsMm4hH2Z0kdkquM++v/eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0
 tHuu2guQOHXvgR1m0vdXcDazv/wor3ElhVsT/h5/WrQ8
------END CERTIFICATE-----
 
 QuoVadis Root CA 2
 ==================
------BEGIN CERTIFICATE-----
 MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0xGTAXBgNVBAoT
 EFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJvb3QgQ0EgMjAeFw0wNjExMjQx
 ODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM

chia/ssl/create_ssl.py

@@ -24,8 +24,9 @@ _all_private_node_names: list[str] = [
     "crawler",
     "data_layer",
     "daemon",
+    "solver",
 ]
-_all_public_node_names: list[str] = ["full_node", "wallet", "farmer", "introducer", "timelord", "data_layer"]
+_all_public_node_names: list[str] = ["full_node", "wallet", "farmer", "introducer", "timelord", "data_layer", "solver"]
 
 
 def get_chia_ca_crt_key() -> tuple[Any, Any]:
@@ -36,7 +37,7 @@ def get_chia_ca_crt_key() -> tuple[Any, Any]:
 
 
 def get_mozilla_ca_crt() -> str:
-    mozilla_path = Path(__file__).parent.parent.parent.absolute() / "mozilla-ca/cacert.pem"
+    mozilla_path = Path(__file__).parent.absolute() / "cacert.pem"
     return str(mozilla_path)
 
 

chia/{server → timelord}/start_timelord.py

@@ -11,13 +11,13 @@ from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.protocols.outbound_message import NodeType
-from chia.server.aliases import TimelordService
 from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
 from chia.timelord.timelord import Timelord
 from chia.timelord.timelord_api import TimelordAPI
 from chia.timelord.timelord_rpc_api import TimelordRpcApi
+from chia.timelord.timelord_service import TimelordService
 from chia.util.chia_logging import initialize_service_logging
 from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path

chia/timelord/timelord.py

@@ -160,20 +160,19 @@ class Timelord:
         slow_bluebox = self.config.get("slow_bluebox", False)
         if not self.bluebox_mode:
             self.main_loop = create_referenced_task(self._manage_chains())
+        elif os.name == "nt" or slow_bluebox:
+            # `vdf_client` doesn't build on windows, use `prove()` from chiavdf.
+            workers = self.config.get("slow_bluebox_process_count", 1)
+            self._executor_shutdown_tempfile = _create_shutdown_file()
+            self.bluebox_pool = ThreadPoolExecutor(
+                max_workers=workers,
+                thread_name_prefix="blue-box-",
+            )
+            self.main_loop = create_referenced_task(
+                self._start_manage_discriminant_queue_sanitizer_slow(self.bluebox_pool, workers)
+            )
         else:
-            if os.name == "nt" or slow_bluebox:
-                # `vdf_client` doesn't build on windows, use `prove()` from chiavdf.
-                workers = self.config.get("slow_bluebox_process_count", 1)
-                self._executor_shutdown_tempfile = _create_shutdown_file()
-                self.bluebox_pool = ThreadPoolExecutor(
-                    max_workers=workers,
-                    thread_name_prefix="blue-box-",
-                )
-                self.main_loop = create_referenced_task(
-                    self._start_manage_discriminant_queue_sanitizer_slow(self.bluebox_pool, workers)
-                )
-            else:
-                self.main_loop = create_referenced_task(self._manage_discriminant_queue_sanitizer())
+            self.main_loop = create_referenced_task(self._manage_discriminant_queue_sanitizer())
         log.info(f"Started timelord, listening on port {self.get_vdf_server_port()}")
         try:
             yield

chia/timelord/timelord_service.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from chia.server.start_service import Service
+from chia.timelord.timelord import Timelord
+from chia.timelord.timelord_api import TimelordAPI
+from chia.timelord.timelord_rpc_api import TimelordRpcApi
+
+TimelordService = Service[Timelord, TimelordAPI, TimelordRpcApi]

chia/types/blockchain_format/proof_of_space.py

@@ -13,23 +13,64 @@ from chia.util.hash import std_hash
 
 log = logging.getLogger(__name__)
 
-
-def get_plot_id(pos: ProofOfSpace) -> bytes32:
-    assert pos.pool_public_key is None or pos.pool_contract_puzzle_hash is None
-    if pos.pool_public_key is None:
-        assert pos.pool_contract_puzzle_hash is not None
-        return calculate_plot_id_ph(pos.pool_contract_puzzle_hash, pos.plot_public_key)
-    return calculate_plot_id_pk(pos.pool_public_key, pos.plot_public_key)
+# These are temporary stubs for chiapos2, that we build against until it's ready to be integrated.
 
 
 # returns quality string for v2 plot, or None if invalid
 def validate_proof_v2(
-    plot_id: bytes32, size: uint8, difficulty: uint8, challenge: bytes32, proof: bytes
+    plot_id: bytes32, size: uint8, required_plot_strength: uint8, challenge: bytes32, proof: bytes
 ) -> Optional[bytes32]:
     # TODO: todo_v2_plots call into new chiapos library
     raise NotImplementedError
 
 
+# this is compute intensive, solving a partial proof returning a full proof
+def solve_proof(partial_proof: bytes) -> bytes:
+    # TODO: todo_v2_plots call into new chiapos library
+    raise NotImplementedError
+
+
+# given a partial proof, computes the quality. This is used to compute required iters.
+def quality_for_partial_proof(partial_proof: bytes, challenge: bytes32) -> bytes32:
+    # TODO: todo_v2_plots call into new chiapos library
+    return std_hash(partial_proof + challenge)
+
+
+def make_pos(
+    challenge: bytes32,
+    pool_public_key: Optional[G1Element],
+    pool_contract_puzzle_hash: Optional[bytes32],
+    plot_public_key: G1Element,
+    version_and_size: PlotSize,
+    proof: bytes,
+) -> ProofOfSpace:
+    k: int
+    if version_and_size.size_v1 is not None:
+        k = version_and_size.size_v1
+    else:
+        assert version_and_size.size_v2 is not None
+        k = version_and_size.size_v2
+        assert k is not None
+        k |= 0x80
+
+    return ProofOfSpace(
+        challenge,
+        pool_public_key,
+        pool_contract_puzzle_hash,
+        plot_public_key,
+        uint8(k),
+        proof,
+    )
+
+
+def get_plot_id(pos: ProofOfSpace) -> bytes32:
+    assert pos.pool_public_key is None or pos.pool_contract_puzzle_hash is None
+    if pos.pool_public_key is None:
+        assert pos.pool_contract_puzzle_hash is not None
+        return calculate_plot_id_ph(pos.pool_contract_puzzle_hash, pos.plot_public_key)
+    return calculate_plot_id_pk(pos.pool_public_key, pos.plot_public_key)
+
+
 def check_plot_size(constants: ConsensusConstants, ps: PlotSize) -> bool:
     size_v1 = ps.size_v1
     if size_v1 is not None:
@@ -50,6 +91,9 @@ def check_plot_size(constants: ConsensusConstants, ps: PlotSize) -> bool:
     if size_v2 > constants.MAX_PLOT_SIZE_V2:
         log.error("Plot size is higher than the maximum")
         return False
+    if (size_v2 & 1) == 1:
+        log.error("Plot size is odd")
+        return False
     return True
 
 
@@ -98,8 +142,8 @@ def verify_and_get_quality_string(
         # === V2 plots ===
         assert plot_size.size_v2 is not None
 
-        plot_difficulty = calculate_plot_difficulty(constants, height)
-        return validate_proof_v2(plot_id, plot_size.size_v2, plot_difficulty, pos.challenge, bytes(pos.proof))
+        required_plot_strength = calculate_required_plot_strength(constants, height)
+        return validate_proof_v2(plot_id, plot_size.size_v2, required_plot_strength, pos.challenge, bytes(pos.proof))
 
 
 def passes_plot_filter(
@@ -137,16 +181,16 @@ def calculate_prefix_bits(constants: ConsensusConstants, height: uint32, plot_si
     return max(0, prefix_bits)
 
 
-def calculate_plot_difficulty(constants: ConsensusConstants, height: uint32) -> uint8:
-    if height < constants.PLOT_DIFFICULTY_4_HEIGHT:
-        return constants.PLOT_DIFFICULTY_INITIAL
-    if height < constants.PLOT_DIFFICULTY_5_HEIGHT:
+def calculate_required_plot_strength(constants: ConsensusConstants, height: uint32) -> uint8:
+    if height < constants.PLOT_STRENGTH_4_HEIGHT:
+        return constants.PLOT_STRENGTH_INITIAL
+    if height < constants.PLOT_STRENGTH_5_HEIGHT:
         return uint8(4)
-    if height < constants.PLOT_DIFFICULTY_6_HEIGHT:
+    if height < constants.PLOT_STRENGTH_6_HEIGHT:
         return uint8(5)
-    if height < constants.PLOT_DIFFICULTY_7_HEIGHT:
+    if height < constants.PLOT_STRENGTH_7_HEIGHT:
         return uint8(6)
-    if height < constants.PLOT_DIFFICULTY_8_HEIGHT:
+    if height < constants.PLOT_STRENGTH_8_HEIGHT:
         return uint8(7)
     else:
         return uint8(8)

chia/types/coin_spend.py

@@ -10,7 +10,6 @@ from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.util.streamable import Streamable, streamable
 
 
 def make_spend(
@@ -36,13 +35,6 @@ def make_spend(
     return CoinSpend(coin, pr, sol)
 
 
-@streamable
-@dataclass(frozen=True)
-class SpendInfo(Streamable):
-    puzzle: SerializedProgram
-    solution: SerializedProgram
-
-
 @dataclass(frozen=True)
 class CoinSpendWithConditions:
     coin_spend: CoinSpend

chia/types/internal_mempool_item.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from chia_rs import SpendBundle, SpendBundleConditions
+from chia_rs import G2Element, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
@@ -11,8 +11,8 @@ from chia.types.mempool_item import BundleCoinSpend
 
 @dataclass(frozen=True)
 class InternalMempoolItem:
-    spend_bundle: SpendBundle
+    aggregated_signature: G2Element
     conds: SpendBundleConditions
     height_added_to_mempool: uint32
-    # Map of coin ID to coin spend data between the bundle and its NPCResult
+    # Map of coin ID to coin spend data between the bundle and its SpendBundleConditions
     bundle_coin_spends: dict[bytes32, BundleCoinSpend]

chia/types/mempool_item.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
-from chia_rs import CoinSpend, SpendBundle, SpendBundleConditions
+from chia_rs import CoinSpend, G2Element, SpendBundle, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -22,21 +22,25 @@ class UnspentLineageInfo:
 class BundleCoinSpend:
     coin_spend: CoinSpend
     eligible_for_dedup: bool
-    eligible_for_fast_forward: bool
     additions: list[Coin]
-    # cost on the specific solution in this item
-    cost: Optional[uint64] = None
+    # cost on the specific solution in this item. The cost includes execution
+    # cost and conditions cost, not byte-cost.
+    cost: uint64
 
     # if this spend is eligible for fast forward, this may be set to the
     # current unspent lineage belonging to this singleton, that we would rebase
     # this spend on top of if we were to make a block now
     # When finding MempoolItems by coin ID, we use Coin ID from it if it's set
-    latest_singleton_lineage: Optional[UnspentLineageInfo] = None
+    latest_singleton_lineage: Optional[UnspentLineageInfo]
+
+    @property
+    def supports_fast_forward(self) -> bool:
+        return self.latest_singleton_lineage is not None
 
 
 @dataclass(frozen=True)
 class MempoolItem:
-    spend_bundle: SpendBundle
+    aggregated_signature: G2Element
     fee: uint64
     conds: SpendBundleConditions
     spend_bundle_name: bytes32
@@ -83,11 +87,11 @@ class MempoolItem:
 
     @property
     def removals(self) -> list[Coin]:
-        return self.spend_bundle.removals()
+        return [bcs.coin_spend.coin for bcs in self.bundle_coin_spends.values()]
 
     def to_json_dict(self) -> dict[str, Any]:
         return {
-            "spend_bundle": recurse_jsonify(self.spend_bundle),
+            "spend_bundle": recurse_jsonify(self.to_spend_bundle()),
             "fee": recurse_jsonify(self.fee),
             "npc_result": {"Error": None, "conds": recurse_jsonify(self.conds)},
             "cost": recurse_jsonify(self.cost),
@@ -95,3 +99,6 @@ class MempoolItem:
             "additions": recurse_jsonify(self.additions),
             "removals": recurse_jsonify(self.removals),
         }
+
+    def to_spend_bundle(self) -> SpendBundle:
+        return SpendBundle([bcs.coin_spend for bcs in self.bundle_coin_spends.values()], self.aggregated_signature)

chia/types/mempool_submission_status.py

@@ -22,7 +22,7 @@ class MempoolSubmissionStatus(Streamable):
     inclusion_status: uint8  # MempoolInclusionStatus
     error_msg: Optional[str]
 
-    def to_json_dict_convenience(self) -> dict[str, Union[str, MempoolInclusionStatus, Optional[str]]]:
+    def to_json_dict_convenience(self) -> dict[str, Union[str, MempoolInclusionStatus, None]]:
         formatted = self.to_json_dict()
         formatted["inclusion_status"] = MempoolInclusionStatus(self.inclusion_status).name
         return formatted