chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/simulator/full_node_simulator.py

@@ -4,10 +4,10 @@ import asyncio
 import itertools
 import time
 from collections.abc import Collection
-from typing import Any, Optional, Union
+from typing import Any
 
 import anyio
-from chia_rs import BlockRecord, FullBlock, SpendBundle
+from chia_rs import BlockRecord, CoinRecord, FullBlock, SpendBundle
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
@@ -24,7 +24,6 @@ from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, GetAllCoinsProtocol, ReorgProtocol
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_record import CoinRecord
 from chia.types.validation_state import ValidationState
 from chia.util.config import lock_and_load_config, save_config
 from chia.util.timing import adjusted_timeout, backoff_times
@@ -45,7 +44,7 @@ default = _Default()
 timeout_per_block = 5
 
 
-async def wait_for_coins_in_wallet(coins: set[Coin], wallet: Wallet, timeout: Optional[float] = 5):
+async def wait_for_coins_in_wallet(coins: set[Coin], wallet: Wallet, timeout: float | None = 5):
     """Wait until all of the specified coins are simultaneously reported as spendable
     by the wallet.
 
@@ -72,16 +71,16 @@ class FullNodeSimulator(FullNodeAPI):
         self.bt = block_tools
         self.full_node = full_node
         self.config = config
-        self.time_per_block: Optional[float] = None
+        self.time_per_block: float | None = None
         self.full_node.simulator_transaction_callback = self.autofarm_transaction
         self.use_current_time: bool = self.config.get("simulator", {}).get("use_current_time", False)
         self.auto_farm: bool = self.config.get("simulator", {}).get("auto_farm", False)
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> list[dict[str, Any]]:
         return default_get_connections(server=self.server, request_node_type=request_node_type)
 
     async def get_all_full_blocks(self) -> list[FullBlock]:
-        peak: Optional[BlockRecord] = self.full_node.blockchain.get_peak()
+        peak: BlockRecord | None = self.full_node.blockchain.get_peak()
         if peak is None:
             return []
         blocks = []
@@ -158,7 +157,7 @@ class FullNodeSimulator(FullNodeAPI):
         Note: This does not broadcast the changes, and all wallets will need to be wiped.
         """
         async with self.full_node.blockchain.priority_mutex.acquire(priority=BlockchainMutexPriority.high):
-            peak_height: Optional[uint32] = self.full_node.blockchain.get_peak_height()
+            peak_height: uint32 | None = self.full_node.blockchain.get_peak_height()
             if peak_height is None:
                 raise ValueError("We can't revert without any blocks.")
             elif peak_height - 1 < new_height:
@@ -237,12 +236,17 @@ class FullNodeSimulator(FullNodeAPI):
 
             current_blocks = await self.get_all_full_blocks()
             target = request.puzzle_hash
+            pool_target: bytes32 | None = target
+            if current_blocks[-1].height >= self.full_node.constants.HARD_FORK2_HEIGHT - 1:
+                # v2 plots (which we start farming at the hard fork activation)
+                # don't support specifying the pool target
+                pool_target = None
             more = self.bt.get_consecutive_blocks(
                 1,
                 time_per_block=time_per_block,
                 transaction_data=spend_bundle,
                 farmer_reward_puzzle_hash=target,
-                pool_reward_puzzle_hash=target,
+                pool_reward_puzzle_hash=pool_target,
                 block_list_input=current_blocks,
                 guarantee_transaction_block=True,
                 current_time=current_time,
@@ -289,11 +293,16 @@ class FullNodeSimulator(FullNodeAPI):
                 spend_bundle = mempool_bundle[0]
             current_blocks = await self.get_all_full_blocks()
             target = request.puzzle_hash
+            pool_target: bytes32 | None = target
+            if current_blocks[-1].height >= self.full_node.constants.HARD_FORK2_HEIGHT - 1:
+                # v2 plots (which we start farming at the hard fork activation)
+                # don't support specifying the pool target
+                pool_target = None
             more = self.bt.get_consecutive_blocks(
                 1,
                 transaction_data=spend_bundle,
                 farmer_reward_puzzle_hash=target,
-                pool_reward_puzzle_hash=target,
+                pool_reward_puzzle_hash=pool_target,
                 block_list_input=current_blocks,
                 current_time=current_time,
                 time_per_block=time_per_block,
@@ -311,10 +320,15 @@ class FullNodeSimulator(FullNodeAPI):
         current_blocks = await self.get_all_full_blocks()
         block_count = new_index - old_index
 
+        pool_target: bytes32 | None = coinbase_ph
+        if current_blocks[-1].height >= self.full_node.constants.HARD_FORK2_HEIGHT - 1:
+            # v2 plots (which we start farming at the hard fork activation)
+            # don't support specifying the pool target
+            pool_target = None
         more_blocks = self.bt.get_consecutive_blocks(
             block_count,
             farmer_reward_puzzle_hash=coinbase_ph,
-            pool_reward_puzzle_hash=coinbase_ph,
+            pool_reward_puzzle_hash=pool_target,
             block_list_input=current_blocks[: old_index + 1],
             force_overflow=True,
             guarantee_transaction_block=True,
@@ -327,7 +341,7 @@ class FullNodeSimulator(FullNodeAPI):
         count: int,
         farm_to: bytes32 = bytes32.zeros,
         guarantee_transaction_blocks: bool = False,
-        timeout: Union[_Default, float, None] = default,
+        timeout: _Default | float | None = default,
         _wait_for_synced: bool = True,
     ) -> int:
         """Process the requested number of blocks including farming to the passed puzzle
@@ -371,7 +385,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         count: int,
         wallet: Wallet,
-        timeout: Union[_Default, float, None] = default,
+        timeout: _Default | float | None = default,
         _wait_for_synced: bool = True,
     ) -> int:
         """Farm the requested number of blocks to the passed wallet. This will
@@ -398,12 +412,19 @@ class FullNodeSimulator(FullNodeAPI):
             rewards = 0
 
             block_reward_coins = set()
-            expected_reward_coin_count = 2 * count
 
             original_peak_height = self.full_node.blockchain.get_peak_height()
             expected_peak_height = 0 if original_peak_height is None else original_peak_height
             extra_blocks = [[False, False]] if original_peak_height is None else []  # Farm genesis block first
 
+            if expected_peak_height >= self.full_node.constants.HARD_FORK2_HEIGHT - 1:
+                # v2 plots (which we start farming at the hard fork activation)
+                # don't support specifying the pool target, so we only get the
+                # farmer reward, not the pool reward
+                expected_reward_coin_count = count
+            else:
+                expected_reward_coin_count = 2 * count
+
             for to_wallet, tx_block in [*extra_blocks, *([[True, False]] * (count - 1)), [True, True], [False, True]]:
                 # This complicated application of the last two blocks being transaction
                 # blocks is due to the transaction blocks only including rewards from
@@ -444,7 +465,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         amount: int,
         wallet: Wallet,
-        timeout: Union[_Default, float, None] = default,
+        timeout: _Default | float | None = default,
     ) -> int:
         """Farm at least the requested amount of mojos to the passed wallet. Extra
         mojos will be received based on the block rewards at the present block height.
@@ -462,7 +483,7 @@ class FullNodeSimulator(FullNodeAPI):
         if amount == 0:
             return rewards
 
-        height_before: Optional[uint32] = self.full_node.blockchain.get_peak_height()
+        height_before: uint32 | None = self.full_node.blockchain.get_peak_height()
         if height_before is None:
             height_before = uint32(0)
 
@@ -484,8 +505,8 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def wait_transaction_records_entered_mempool(
         self,
-        records: Collection[Union[TransactionRecord, LightTransactionRecord]],
-        timeout: Union[float, None] = 5,
+        records: Collection[TransactionRecord | LightTransactionRecord],
+        timeout: float | None = 5,
     ) -> None:
         """Wait until the transaction records have entered the mempool.  Transaction
         records with no spend bundle are ignored.
@@ -517,7 +538,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def wait_bundle_ids_in_mempool(
         self,
         bundle_ids: Collection[bytes32],
-        timeout: Union[float, None] = 5,
+        timeout: float | None = 5,
     ) -> None:
         """Wait until the ids of specific spend bundles have entered the mempool.
 
@@ -544,7 +565,7 @@ class FullNodeSimulator(FullNodeAPI):
         self,
         record_ids: Collection[bytes32],
         wallet_node: WalletNode,
-        timeout: Union[float, None] = 10,
+        timeout: float | None = 10,
     ) -> None:
         """Wait until the transaction records have been marked that they have made it into the mempool.  Transaction
         records with no spend bundle are ignored.
@@ -571,7 +592,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def process_transaction_records(
         self,
         records: Collection[TransactionRecord],
-        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
+        timeout: float | None = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified transaction records and wait until they have been
         included in a block.
@@ -596,7 +617,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def process_spend_bundles(
         self,
         bundles: Collection[SpendBundle],
-        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
+        timeout: float | None = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified spend bundles and wait until they have been included
         in a block.
@@ -612,7 +633,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def process_coin_spends(
         self,
         coins: Collection[Coin],
-        timeout: Union[float, None] = (2 * timeout_per_block) + 5,
+        timeout: float | None = (2 * timeout_per_block) + 5,
     ) -> None:
         """Process the specified coin names and wait until they have been created in a
         block.
@@ -639,10 +660,10 @@ class FullNodeSimulator(FullNodeAPI):
                 if len(coin_set) == 0:
                     return
 
-    async def process_all_wallet_transactions(self, wallet: Wallet, timeout: Optional[float] = 5) -> None:
+    async def process_all_wallet_transactions(self, wallet: Wallet, timeout: float | None = 5) -> None:
         # TODO: Maybe something could be done around waiting for the tx to enter the
         #       mempool.  Maybe not, might be too many races or such.
-        wallet_state_manager: Optional[WalletStateManager] = wallet.wallet_state_manager
+        wallet_state_manager: WalletStateManager | None = wallet.wallet_state_manager
         assert wallet_state_manager is not None
 
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
@@ -664,8 +685,8 @@ class FullNodeSimulator(FullNodeAPI):
     async def check_transactions_confirmed(
         self,
         wallet_state_manager: WalletStateManager,
-        transactions: Union[list[TransactionRecord], list[LightTransactionRecord]],
-        timeout: Optional[float] = 5,
+        transactions: list[TransactionRecord] | list[LightTransactionRecord],
+        timeout: float | None = 5,
     ) -> None:
         transactions_left: set[bytes32] = {tx.name for tx in transactions}
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
@@ -682,7 +703,7 @@ class FullNodeSimulator(FullNodeAPI):
         amounts: list[uint64],
         wallet: Wallet,
         per_transaction_record_group: int = 50,
-        timeout: Union[float, None] = 15,
+        timeout: float | None = 15,
     ) -> set[Coin]:
         """Create coins with the requested amount.  This is useful when you need a
         bunch of coins for a test and don't need to farm that many.
@@ -760,7 +781,7 @@ class FullNodeSimulator(FullNodeAPI):
     async def self_is_synced(self) -> bool:
         return await self.full_node.synced()
 
-    async def wallet_is_synced(self, wallet_node: WalletNode, peak_height: Optional[uint32] = None) -> bool:
+    async def wallet_is_synced(self, wallet_node: WalletNode, peak_height: uint32 | None = None) -> bool:
         if not await self.self_is_synced():
             # Depending on races, may not be covered every time
             return False  # pragma: no cover
@@ -776,8 +797,8 @@ class FullNodeSimulator(FullNodeAPI):
     async def wait_for_wallet_synced(
         self,
         wallet_node: WalletNode,
-        timeout: Optional[float] = 5,
-        peak_height: Optional[uint32] = None,
+        timeout: float | None = 5,
+        peak_height: uint32 | None = None,
     ) -> None:
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
             for backoff_time in backoff_times():
@@ -785,7 +806,7 @@ class FullNodeSimulator(FullNodeAPI):
                     break
                 await asyncio.sleep(backoff_time)
 
-    async def wallets_are_synced(self, wallet_nodes: list[WalletNode], peak_height: Optional[uint32] = None) -> bool:
+    async def wallets_are_synced(self, wallet_nodes: list[WalletNode], peak_height: uint32 | None = None) -> bool:
         return all(
             [
                 await self.wallet_is_synced(wallet_node=wallet_node, peak_height=peak_height)
@@ -796,8 +817,8 @@ class FullNodeSimulator(FullNodeAPI):
     async def wait_for_wallets_synced(
         self,
         wallet_nodes: list[WalletNode],
-        timeout: Optional[float] = 5,
-        peak_height: Optional[uint32] = None,
+        timeout: float | None = 5,
+        peak_height: uint32 | None = None,
     ) -> None:
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
             for backoff_time in backoff_times():
@@ -807,7 +828,7 @@ class FullNodeSimulator(FullNodeAPI):
 
     async def wait_for_self_synced(
         self,
-        timeout: Optional[float] = 5,
+        timeout: float | None = 5,
     ) -> None:
         with anyio.fail_after(delay=adjusted_timeout(timeout)):
             for backoff_time in backoff_times():

chia/simulator/keyring.py

@@ -4,7 +4,6 @@ import os
 import shutil
 import tempfile
 from pathlib import Path
-from typing import Optional
 from unittest.mock import patch
 
 from chia.util.file_keyring import FileKeyring, keyring_path_from_root
@@ -44,7 +43,7 @@ class TempKeyring:
         user: str = "testing-1.8.0",
         service: str = "testing-chia-1.8.0",
         populate: bool = False,
-        existing_keyring_path: Optional[str] = None,
+        existing_keyring_path: str | None = None,
         delete_on_cleanup: bool = True,
         use_os_credential_store: bool = False,
     ):
@@ -65,7 +64,7 @@ class TempKeyring:
         user: str,
         service: str,
         populate: bool,
-        existing_keyring_path: Optional[str],
+        existing_keyring_path: str | None,
         use_os_credential_store: bool,
     ):
         existing_keyring_dir = Path(existing_keyring_path).parent if existing_keyring_path else None

chia/simulator/setup_services.py

@@ -9,7 +9,7 @@ from collections.abc import AsyncGenerator, AsyncIterator, Iterator
 from contextlib import asynccontextmanager, contextmanager
 from pathlib import Path
 from types import FrameType
-from typing import Any, Optional, Union
+from typing import Any
 
 from chia_rs import ConsensusConstants
 from chia_rs.sized_bytes import bytes32
@@ -100,18 +100,18 @@ async def setup_full_node(
     db_name: str,
     self_hostname: str,
     local_bt: BlockTools,
-    introducer_port: Optional[int] = None,
+    introducer_port: int | None = None,
     simulator: bool = False,
     send_uncompact_interval: int = 0,
     sanitize_weight_proof_only: bool = False,
     connect_to_daemon: bool = False,
     db_version: int = 1,
-    disable_capabilities: Optional[list[Capability]] = None,
+    disable_capabilities: list[Capability] | None = None,
     *,
     reuse_db: bool = False,
-) -> AsyncGenerator[Union[FullNodeService, SimulatorFullNodeService], None]:
+) -> AsyncGenerator[FullNodeService | SimulatorFullNodeService, None]:
     if reuse_db:
-        db_path: Union[str, Path] = local_bt.root_path / f"{db_name}"
+        db_path: str | Path = local_bt.root_path / f"{db_name}"
         uri = False
     else:
         db_path = generate_in_memory_db_uri()
@@ -149,7 +149,7 @@ async def setup_full_node(
     override_capabilities = (
         None if disable_capabilities is None else get_capability_overrides(NodeType.FULL_NODE, disable_capabilities)
     )
-    service: Union[FullNodeService, SimulatorFullNodeService]
+    service: FullNodeService | SimulatorFullNodeService
     if simulator:
         service = await create_full_node_simulator_service(
             local_bt.root_path,
@@ -232,11 +232,11 @@ async def setup_wallet_node(
     self_hostname: str,
     consensus_constants: ConsensusConstants,
     local_bt: BlockTools,
-    spam_filter_after_n_txs: Optional[int] = 200,
+    spam_filter_after_n_txs: int | None = 200,
     xch_spam_amount: int = 1000000,
-    full_node_port: Optional[uint16] = None,
-    introducer_port: Optional[uint16] = None,
-    key_seed: Optional[bytes] = None,
+    full_node_port: uint16 | None = None,
+    introducer_port: uint16 | None = None,
+    key_seed: bytes | None = None,
     initial_num_public_keys: int = 5,
 ) -> AsyncGenerator[WalletService, None]:
     with TempKeyring(populate=True) as keychain:
@@ -324,7 +324,7 @@ async def setup_wallet_node(
 async def setup_harvester(
     b_tools: BlockTools,
     root_path: Path,
-    farmer_peer: Optional[UnresolvedPeerInfo],
+    farmer_peer: UnresolvedPeerInfo | None,
     consensus_constants: ConsensusConstants,
     start_service: bool = True,
 ) -> AsyncGenerator[HarvesterService, None]:
@@ -356,10 +356,10 @@ async def setup_farmer(
     root_path: Path,
     self_hostname: str,
     consensus_constants: ConsensusConstants,
-    full_node_port: Optional[uint16] = None,
+    full_node_port: uint16 | None = None,
     start_service: bool = True,
     port: uint16 = uint16(0),
-    solver_peer: Optional[UnresolvedPeerInfo] = None,
+    solver_peer: UnresolvedPeerInfo | None = None,
 ) -> AsyncGenerator[FarmerService, None]:
     with create_lock_and_load_config(b_tools.root_path / "config" / "ssl" / "ca", root_path) as root_config:
         root_config["logging"]["log_stdout"] = True
@@ -435,7 +435,7 @@ async def setup_vdf_client(bt: BlockTools, self_hostname: str, port: int) -> Asy
 
     async def stop(
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         await process_mgr.kill_processes()
@@ -472,7 +472,7 @@ async def setup_vdf_clients(bt: BlockTools, self_hostname: str, port: int) -> As
 
     async def stop(
         signal_: signal.Signals,
-        stack_frame: Optional[FrameType],
+        stack_frame: FrameType | None,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         await process_mgr.kill_processes()

chia/simulator/simulator_full_node_rpc_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from chia_rs import FullBlock
+from chia_rs import CoinRecord, FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
@@ -8,7 +8,6 @@ from chia.full_node.full_node_rpc_api import FullNodeRpcApi
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, GetAllCoinsProtocol, ReorgProtocol
-from chia.types.coin_record import CoinRecord
 from chia.util.bech32m import decode_puzzle_hash
 
 

chia/simulator/simulator_full_node_rpc_client.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from chia_rs import FullBlock
+from chia_rs import CoinRecord, FullBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint128
 
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
-from chia.types.coin_record import CoinRecord
 from chia.util.bech32m import encode_puzzle_hash
 
 

chia/simulator/simulator_protocol.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -21,7 +20,7 @@ class ReorgProtocol(Streamable):
     old_index: uint32
     new_index: uint32
     puzzle_hash: bytes32
-    seed: Optional[bytes32]
+    seed: bytes32 | None
 
 
 @streamable

chia/simulator/simulator_test_tools.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import PrivateKey
 from chia_rs.sized_bytes import bytes32
@@ -118,9 +118,9 @@ async def start_simulator(chia_root: Path, automated_testing: bool = False) -> A
 
 async def get_full_chia_simulator(
     chia_root: Path,
-    keychain: Optional[Keychain] = None,
+    keychain: Keychain | None = None,
     automated_testing: bool = False,
-    config: Optional[dict[str, Any]] = None,
+    config: dict[str, Any] | None = None,
 ) -> AsyncGenerator[tuple[FullNodeSimulator, Path, dict[str, Any], str, int, Keychain], None]:
     """
     A chia root Path is required.

chia/simulator/start_simulator.py

@@ -5,12 +5,12 @@ import sys
 from dataclasses import dataclass
 from multiprocessing import freeze_support
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.full_node.full_node import FullNode
 from chia.protocols.outbound_message import NodeType
 from chia.server.signal_handlers import SignalHandlers
@@ -39,7 +39,7 @@ async def create_full_node_simulator_service(
     config: dict[str, Any],
     bt: BlockTools,
     connect_to_daemon: bool = True,
-    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
+    override_capabilities: list[tuple[uint16, str]] | None = None,
 ) -> SimulatorFullNodeService:
     service_config = config[SERVICE_NAME]
     constants = bt.constants
@@ -65,7 +65,7 @@ async def create_full_node_simulator_service(
         rpc_info=(SimulatorFullNodeRpcApi, service_config["rpc_port"]),
         connect_to_daemon=connect_to_daemon,
         override_capabilities=override_capabilities,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 
@@ -78,7 +78,7 @@ class StartedSimulator:
 async def async_main(
     test_mode: bool = False,
     automated_testing: bool = False,
-    root_path: Optional[Path] = None,
+    root_path: Path | None = None,
 ) -> StartedSimulator:
     root_path = resolve_root_path(override=root_path)
     # helping mypy out for now
@@ -89,8 +89,8 @@ async def async_main(
     service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
     # THIS IS Simulator specific.
-    fingerprint: Optional[int] = None
-    farming_puzzle_hash: Optional[bytes32] = None
+    fingerprint: int | None = None
+    farming_puzzle_hash: bytes32 | None = None
     plot_dir: str = "simulator/plots"
     if "simulator" in config:
         overrides = {}

chia/simulator/wallet_tools.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import AugSchemeMPL, CoinSpend, ConsensusConstants, G1Element, G2Element, PrivateKey, SpendBundle
 from chia_rs.sized_bytes import bytes32
@@ -37,7 +37,7 @@ class WalletTool:
     pubkey_num_lookup: dict[bytes, uint32] = {}  # noqa: RUF012
     puzzle_pk_cache: dict[bytes32, PrivateKey] = {}  # noqa: RUF012
 
-    def __init__(self, constants: ConsensusConstants, sk: Optional[PrivateKey] = None):
+    def __init__(self, constants: ConsensusConstants, sk: PrivateKey | None = None):
         self.constants = constants
         self.current_balance = 0
         self.my_utxos: set = set()
@@ -106,9 +106,9 @@ class WalletTool:
         coins: list[Coin],
         condition_dic: dict[ConditionOpcode, list[ConditionWithArgs]],
         fee: int = 0,
-        secret_key: Optional[PrivateKey] = None,
-        additional_outputs: Optional[list[tuple[bytes32, int]]] = None,
-        memo: Optional[bytes32] = None,
+        secret_key: PrivateKey | None = None,
+        additional_outputs: list[tuple[bytes32, int]] | None = None,
+        memo: bytes32 | None = None,
     ) -> list[CoinSpend]:
         spends = []
 
@@ -206,10 +206,10 @@ class WalletTool:
         amount: uint64,
         new_puzzle_hash: bytes32,
         coin: Coin,
-        condition_dic: Optional[dict[ConditionOpcode, list[ConditionWithArgs]]] = None,
+        condition_dic: dict[ConditionOpcode, list[ConditionWithArgs]] | None = None,
         fee: int = 0,
-        additional_outputs: Optional[list[tuple[bytes32, int]]] = None,
-        memo: Optional[bytes32] = None,
+        additional_outputs: list[tuple[bytes32, int]] | None = None,
+        memo: bytes32 | None = None,
     ) -> SpendBundle:
         if condition_dic is None:
             condition_dic = {}
@@ -224,9 +224,9 @@ class WalletTool:
         amount: uint64,
         new_puzzle_hash: bytes32,
         coins: list[Coin],
-        condition_dic: Optional[dict[ConditionOpcode, list[ConditionWithArgs]]] = None,
+        condition_dic: dict[ConditionOpcode, list[ConditionWithArgs]] | None = None,
         fee: int = 0,
-        additional_outputs: Optional[list[tuple[bytes32, int]]] = None,
+        additional_outputs: list[tuple[bytes32, int]] | None = None,
     ) -> SpendBundle:
         if condition_dic is None:
             condition_dic = {}

chia/solver/solver.py

@@ -6,15 +6,15 @@ 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 typing import TYPE_CHECKING, Any, ClassVar, cast
 
-from chia_rs import ConsensusConstants
+from chia_rs import ConsensusConstants, PartialProof, solve_proof
+from chia_rs.sized_bytes import bytes32
 
 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__)
 
@@ -26,11 +26,11 @@ class Solver:
         _protocol_check: ClassVar[RpcServiceProtocol] = cast("Solver", None)
 
     root_path: Path
-    _server: Optional[ChiaServer]
+    _server: ChiaServer | None
     _shut_down: bool
     started: bool = False
     executor: ThreadPoolExecutor
-    state_changed_callback: Optional[StateChangedProtocol] = None
+    state_changed_callback: StateChangedProtocol | None = None
     constants: ConsensusConstants
     event_loop: asyncio.events.AbstractEventLoop
 
@@ -51,7 +51,7 @@ class Solver:
         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.state_changed_callback: StateChangedProtocol | None = None
         self.log.info("Solver initialization complete")
 
     @contextlib.asynccontextmanager
@@ -67,15 +67,15 @@ class Solver:
             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()}")
+    def solve(self, partial_proof: PartialProof, plot_id: bytes32, strength: int, size: int) -> bytes | None:
+        self.log.info(f"Solve request: partial={partial_proof.proof_fragments[:5]} plot-id: {plot_id} k: {size}")
         try:
-            return solve_proof(partial_proof)
+            return solve_proof(partial_proof, plot_id, strength, size)
         except Exception:
             self.log.exception("solve_proof()")
         return None
 
-    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+    def get_connections(self, request_node_type: NodeType | None) -> 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: