chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/_tests/core/util/test_streamable.py

@@ -2,16 +2,16 @@ from __future__ import annotations
 
 import io
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, field, fields
 from enum import Enum
-from typing import Any, Callable, ClassVar, Optional, get_type_hints
+from typing import Any, ClassVar, Literal, get_args, get_type_hints
 
 import pytest
 from chia_rs import FullBlock, G1Element, SubEpochChallengeSegment
 from chia_rs.sized_bytes import bytes4, bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 from clvm_tools import binutils
-from typing_extensions import Literal, get_args
 
 from chia.protocols.wallet_protocol import RespondRemovals
 from chia.simulator.block_tools import BlockTools, test_constants
@@ -374,8 +374,8 @@ def test_not_lists() -> None:
 
 
 def test_basic_optional() -> None:
-    assert is_type_SpecificOptional(Optional[int])
-    assert is_type_SpecificOptional(Optional[int])
+    assert is_type_SpecificOptional(int | None)
+    assert is_type_SpecificOptional(int | None)
     assert not is_type_SpecificOptional(list[int])
 
 
@@ -418,10 +418,10 @@ class PostInitTestClassBad(Streamable):
 @streamable
 @dataclass(frozen=True)
 class PostInitTestClassOptional(Streamable):
-    a: Optional[uint8]
-    b: Optional[uint8]
-    c: Optional[uint8]
-    d: Optional[uint8]
+    a: uint8 | None
+    b: uint8 | None
+    c: uint8 | None
+    d: uint8 | None
 
 
 @streamable
@@ -537,8 +537,8 @@ def test_basic() -> None:
         b: uint32
         c: list[uint32]
         d: list[list[uint32]]
-        e: Optional[uint32]
-        f: Optional[uint32]
+        e: uint32 | None
+        f: uint32 | None
         g: tuple[uint32, str, bytes]
         h: dict[uint32, str]
         i: IntegerEnum
@@ -590,9 +590,9 @@ def test_json(bt: BlockTools) -> None:
 @streamable
 @dataclass(frozen=True)
 class OptionalTestClass(Streamable):
-    a: Optional[str]
-    b: Optional[bool]
-    c: Optional[list[Optional[str]]]
+    a: str | None
+    b: bool | None
+    c: list[str | None] | None
 
 
 @pytest.mark.parametrize(
@@ -606,7 +606,7 @@ class OptionalTestClass(Streamable):
         (None, None, None),
     ],
 )
-def test_optional_json(a: Optional[str], b: Optional[bool], c: Optional[list[Optional[str]]]) -> None:
+def test_optional_json(a: str | None, b: bool | None, c: list[str | None] | None) -> None:
     obj: OptionalTestClass = OptionalTestClass.from_json_dict({"a": a, "b": b, "c": c})
     assert obj.a == a
     assert obj.b == b
@@ -623,7 +623,7 @@ class TestClassRecursive1(Streamable):
 @dataclass(frozen=True)
 class TestClassRecursive2(Streamable):
     a: uint32
-    b: list[Optional[list[TestClassRecursive1]]]
+    b: list[list[TestClassRecursive1] | None]
     c: bytes32
 
 
@@ -637,7 +637,7 @@ def test_recursive_json() -> None:
 
 
 def test_recursive_types() -> None:
-    coin: Optional[Coin] = None
+    coin: Coin | None = None
     l1 = [(bytes32([2] * 32), coin)]
     rr = RespondRemovals(uint32(1), bytes32([1] * 32), l1, None)
     RespondRemovals(rr.height, rr.header_hash, rr.coins, rr.proofs)
@@ -650,7 +650,7 @@ def test_ambiguous_deserialization_optionals() -> None:
     @streamable
     @dataclass(frozen=True)
     class TestClassOptional(Streamable):
-        a: Optional[uint8]
+        a: uint8 | None
 
     # Does not have the required elements
     with pytest.raises(AssertionError):

chia/_tests/db/test_db_wrapper.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Optional
+from typing import TYPE_CHECKING
 
 import aiosqlite
 import pytest
@@ -494,7 +495,7 @@ async def test_foreign_key_pragma_rolls_back_on_foreign_key_error() -> None:
 @dataclass
 class RowFactoryCase:
     id: str
-    factory: Optional[type[aiosqlite.Row]]
+    factory: type[aiosqlite.Row] | None
     marks: Marks = ()
 
 

chia/_tests/environments/wallet.py

@@ -6,7 +6,7 @@ import operator
 import unittest
 from collections.abc import Iterator
 from dataclasses import asdict, dataclass, field
-from typing import TYPE_CHECKING, Any, ClassVar, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
@@ -50,9 +50,9 @@ OPP_DICT = {"<": operator.lt, ">": operator.gt, "<=": operator.le, ">=": operato
 
 
 class BalanceCheckingError(Exception):
-    errors: dict[Union[int, str], list[str]]
+    errors: dict[int | str, list[str]]
 
-    def __init__(self, errors: dict[Union[int, str], list[str]]) -> None:
+    def __init__(self, errors: dict[int | str, list[str]]) -> None:
         self.errors = errors
 
     def __repr__(self) -> str:
@@ -69,10 +69,10 @@ class WalletState:
 
 @dataclass
 class WalletStateTransition:
-    pre_block_balance_updates: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
-    post_block_balance_updates: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
-    pre_block_additional_balance_info: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
-    post_block_additional_balance_info: dict[Union[int, str], dict[str, int]] = field(default_factory=dict)
+    pre_block_balance_updates: dict[int | str, dict[str, int]] = field(default_factory=dict)
+    post_block_balance_updates: dict[int | str, dict[str, int]] = field(default_factory=dict)
+    pre_block_additional_balance_info: dict[int | str, dict[str, int]] = field(default_factory=dict)
+    post_block_additional_balance_info: dict[int | str, dict[str, int]] = field(default_factory=dict)
 
 
 @dataclass
@@ -121,7 +121,7 @@ class WalletEnvironment:
     def xch_wallet(self) -> Wallet:
         return self.service._node.wallet_state_manager.main_wallet
 
-    def dealias_wallet_id(self, wallet_id_or_alias: Union[int, str]) -> uint32:
+    def dealias_wallet_id(self, wallet_id_or_alias: int | str) -> uint32:
         """
         This function turns something that is either a wallet id or a wallet alias into a wallet id.
         """
@@ -131,7 +131,7 @@ class WalletEnvironment:
             else uint32(self.wallet_aliases[wallet_id_or_alias])
         )
 
-    def alias_wallet_id(self, wallet_id: uint32) -> Union[uint32, str]:
+    def alias_wallet_id(self, wallet_id: uint32) -> uint32 | str:
         """
         This function turns a wallet id into an alias if one is available or the same wallet id if one is not.
         """
@@ -141,7 +141,7 @@ class WalletEnvironment:
         else:
             return wallet_id
 
-    async def check_balances(self, additional_balance_info: dict[Union[int, str], dict[str, int]] = {}) -> None:
+    async def check_balances(self, additional_balance_info: dict[int | str, dict[str, int]] = {}) -> None:
         """
         This function checks the internal representation of what the balances should be against the balances that the
         wallet actually returns via the RPC.
@@ -151,7 +151,7 @@ class WalletEnvironment:
         dealiased_additional_balance_info: dict[uint32, dict[str, int]] = {
             self.dealias_wallet_id(k): v for k, v in additional_balance_info.items()
         }
-        errors: dict[Union[int, str], list[str]] = {}
+        errors: dict[int | str, list[str]] = {}
         for wallet_id in self.wallet_state_manager.wallets:
             if wallet_id not in self.wallet_states:
                 raise KeyError(f"No wallet state for wallet id {wallet_id} (alias: {self.alias_wallet_id(wallet_id)})")
@@ -189,7 +189,7 @@ class WalletEnvironment:
         if errors != {}:
             raise BalanceCheckingError(errors)
 
-    async def change_balances(self, update_dictionary: dict[Union[int, str], dict[str, int]]) -> None:
+    async def change_balances(self, update_dictionary: dict[int | str, dict[str, int]]) -> None:
         """
         This method changes the internal representation of what the wallet balances should be. This is probably
         necessary to call before check_balances as most wallet operations will result in a balance change that causes
@@ -228,7 +228,7 @@ class WalletEnvironment:
                 )
             else:
                 for key, change in kwargs.items():
-                    if key in "set_remainder":
+                    if key in {"set_remainder", "init"}:
                         continue
                     if "#" in key:
                         opp: str = key[0 : key.index("#")]
@@ -347,7 +347,7 @@ class WalletTestFramework:
         1) Ensures all pending transactions have entered the mempool
         2) Checks that all balances have changed properly prior to a block being farmed
         3) Farms a block (to no one in particular)
-        4) Chacks that all balances have changed properly after the block was farmed
+        4) Checks that all balances have changed properly after the block was farmed
         5) Checks that all pending transactions that were gathered in step 1 are now confirmed
         6) Checks that if `reuse_puzhash` was set, no new derivations were created
         7) Ensures the wallet is in a synced state before progressing to the rest of the test

chia/_tests/ether.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Optional
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from chia._tests.util.misc import TestId
@@ -15,5 +16,5 @@ if TYPE_CHECKING:
 #       result in you likely getting the default `None` values since they are not
 #       populated until tests are running.
 
-record_property: Optional[Callable[[str, object], None]] = None
-test_id: Optional[TestId] = None
+record_property: Callable[[str, object], None] | None = None
+test_id: TestId | None = None

chia/_tests/farmer_harvester/test_farmer.py

@@ -5,11 +5,11 @@ import logging
 from dataclasses import dataclass
 from time import time
 from types import TracebackType
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 from unittest.mock import ANY
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PlotSize, PrivateKey, ProofOfSpace
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PlotParam, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from pytest_mock import MockerFixture
@@ -57,7 +57,7 @@ class IncrementPoolStatsCase:
     name: str
     current_time: float
     count: int
-    value: Optional[Union[int, dict[str, Any]]]
+    value: int | dict[str, Any] | None
     expected_result: Any
 
     def __init__(
@@ -66,7 +66,7 @@ class IncrementPoolStatsCase:
         name: str,
         current_time: float,
         count: int,
-        value: Optional[Union[int, dict[str, Any]]],
+        value: int | dict[str, Any] | None,
         expected_result: Any,
     ):
         prepared_p2_singleton_puzzle_hash = std_hash(b"11223344")
@@ -134,16 +134,16 @@ class NewProofOfSpaceCase:
     plot_identifier: str
     signage_point_index: uint8
     plot_id: bytes32
-    plot_size: PlotSize
+    plot_size: PlotParam
     plot_challenge: bytes32
     plot_public_key: G1Element
-    pool_public_key: Optional[G1Element]
+    pool_public_key: G1Element | None
     pool_contract_puzzle_hash: bytes32
     height: uint32
     proof: bytes
     pool_config: PoolWalletConfig
-    pool_difficulty: Optional[uint64]
-    authentication_token_timeout: Optional[uint8]
+    pool_difficulty: uint64 | None
+    authentication_token_timeout: uint8 | None
     farmer_private_keys: list[PrivateKey]
     authentication_keys: dict[bytes32, PrivateKey]
     use_invalid_peer_response: bool
@@ -157,8 +157,8 @@ class NewProofOfSpaceCase:
         difficulty: uint64,
         sub_slot_iters: uint64,
         pool_url: str,
-        pool_difficulty: Optional[uint64],
-        authentication_token_timeout: Optional[uint8],
+        pool_difficulty: uint64 | None,
+        authentication_token_timeout: uint8 | None,
         use_invalid_peer_response: bool,
         has_valid_authentication_keys: bool,
         expected_pool_stats: dict[str, Any],
@@ -189,7 +189,7 @@ class NewProofOfSpaceCase:
             plot_identifier="test",
             signage_point_index=uint8(1),
             plot_id=bytes32.fromhex("baaa6780c53d4b3739b8807b4ae79a76644ddf0d9e03dc7d0a6a0e613e764d9f"),
-            plot_size=PlotSize.make_v1(32),
+            plot_size=PlotParam.make_v1(32),
             plot_challenge=bytes32.fromhex("7580e4c366dc2c94c37ce44943f9629a3cd6e027d7b24cd014adeaa578d4b0a2"),
             plot_public_key=G1Element.from_bytes(
                 bytes.fromhex(
@@ -626,7 +626,14 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
     }
 
     assert (
-        verify_and_get_quality_string(pos, DEFAULT_CONSTANTS, case.challenge_hash, case.sp_hash, height=uint32(1))
+        verify_and_get_quality_string(
+            pos,
+            DEFAULT_CONSTANTS,
+            case.challenge_hash,
+            case.sp_hash,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
+        )
         is not None
     )
 
@@ -669,9 +676,9 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
 class DummyPoolResponse:
     ok: bool
     status: int
-    error_code: Optional[int] = None
-    error_message: Optional[str] = None
-    new_difficulty: Optional[int] = None
+    error_code: int | None = None
+    error_message: str | None = None
+    new_difficulty: int | None = None
 
     async def text(self) -> str:
         json_dict: dict[str, Any] = dict()
@@ -688,9 +695,9 @@ class DummyPoolResponse:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         pass
 
@@ -883,7 +890,12 @@ async def test_farmer_pool_response(
 
     assert (
         verify_and_get_quality_string(
-            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
+            pos,
+            DEFAULT_CONSTANTS,
+            sp.challenge_hash,
+            sp.challenge_chain_sp,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
         )
         is not None
     )
@@ -998,7 +1010,7 @@ class DummyPoolInfoResponse:
     ok: bool
     status: int
     url: URL
-    pool_info: Optional[dict[str, Any]] = None
+    pool_info: dict[str, Any] | None = None
     history: tuple[DummyClientResponse, ...] = ()
 
     async def text(self) -> str:
@@ -1012,9 +1024,9 @@ class DummyPoolInfoResponse:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         pass
 
@@ -1251,7 +1263,12 @@ async def test_farmer_additional_headers_on_partial_submit(
 
     assert (
         verify_and_get_quality_string(
-            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
+            pos,
+            DEFAULT_CONSTANTS,
+            sp.challenge_hash,
+            sp.challenge_chain_sp,
+            height=uint32(1),
+            prev_transaction_block_height=uint32(1),
         )
         is not None
     )

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -4,11 +4,11 @@ import asyncio
 import unittest.mock
 from math import floor
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 from unittest.mock import AsyncMock, Mock
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, PartialProof
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
@@ -56,12 +56,12 @@ def farmer_is_started(farmer: Farmer) -> bool:
     return farmer.started
 
 
-async def get_harvester_config(harvester_rpc_port: Optional[int], root_path: Path) -> dict[str, Any]:
+async def get_harvester_config(harvester_rpc_port: int | None, root_path: Path) -> dict[str, Any]:
     async with get_any_service_client(HarvesterRpcClient, root_path, harvester_rpc_port) as (harvester_client, _):
         return await harvester_client.get_harvester_config()
 
 
-async def update_harvester_config(harvester_rpc_port: Optional[int], root_path: Path, config: dict[str, Any]) -> bool:
+async def update_harvester_config(harvester_rpc_port: int | None, root_path: Path, config: dict[str, Any]) -> bool:
     async with get_any_service_client(HarvesterRpcClient, root_path, harvester_rpc_port) as (harvester_client, _):
         return await harvester_client.update_harvester_config(config)
 
@@ -325,6 +325,10 @@ async def test_harvester_has_no_server(
     assert harvester_server.webserver is None
 
 
+test_partial_proof = PartialProof([uint64(256)] * 64)
+test_partial_proof2 = PartialProof([uint64(4096)] * 64)
+
+
 @pytest.mark.anyio
 async def test_v2_partial_proofs_new_sp_hash(
     farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
@@ -338,9 +342,11 @@ async def test_v2_partial_proofs_new_sp_hash(
         challenge_hash=bytes32(b"2" * 32),
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_1"],
+        partial_proofs=[test_partial_proof],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        strength=uint8(5),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -367,9 +373,11 @@ async def test_v2_partial_proofs_missing_sp_hash(
         challenge_hash=bytes32(b"2" * 32),
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_1"],
+        partial_proofs=[test_partial_proof],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+        strength=uint8(5),
         pool_public_key=None,
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -409,9 +417,14 @@ async def test_v2_partial_proofs_with_existing_sp(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_1", b"test_partial_proof_2"],
+        partial_proofs=[
+            test_partial_proof,
+            test_partial_proof2,
+        ],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+        strength=uint8(5),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -441,9 +454,11 @@ async def test_solution_response_handler(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_for_quality"],
+        partial_proofs=[test_partial_proof],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+        strength=uint8(5),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -452,7 +467,8 @@ async def test_solution_response_handler(
     harvester_peer = await get_harvester_peer(farmer)
 
     # manually add pending request
-    farmer.pending_solver_requests[partial_proofs.partial_proofs[0]] = {
+    key = bytes(partial_proofs.partial_proofs[0])
+    farmer.pending_solver_requests[key] = {
         "proof_data": partial_proofs,
         "peer": harvester_peer,
     }
@@ -477,7 +493,8 @@ async def test_solution_response_handler(
         assert original_peer == harvester_peer
 
         # verify pending request was removed
-        assert partial_proofs.partial_proofs[0] not in farmer.pending_solver_requests
+        key = bytes(partial_proofs.partial_proofs[0])
+        assert key not in farmer.pending_solver_requests
 
 
 @pytest.mark.anyio
@@ -492,7 +509,10 @@ async def test_solution_response_unknown_quality(
     solver_peer = await get_solver_peer(farmer)
 
     # create solution response with unknown quality
-    solution_response = solver_protocol.SolverResponse(partial_proof=bytes(b"1" * 32), proof=b"test_proof")
+    solution_response = solver_protocol.SolverResponse(
+        partial_proof=test_partial_proof,
+        proof=b"test_proof",
+    )
 
     with unittest.mock.patch.object(farmer_api, "new_proof_of_space", new_callable=AsyncMock) as mock_new_proof:
         await farmer_api.solution_response(solution_response, solver_peer)
@@ -518,9 +538,14 @@ async def test_solution_response_empty_proof(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_for_quality"],
+        partial_proofs=[
+            test_partial_proof,
+            test_partial_proof2,
+        ],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+        strength=uint8(5),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -530,8 +555,9 @@ async def test_solution_response_empty_proof(
     harvester_peer.peer_node_id = "harvester_peer"
 
     # manually add pending request
-    farmer.pending_solver_requests[partial_proofs.partial_proofs[0]] = {
-        "proof_data": partial_proofs.partial_proofs[0],
+    key = bytes(partial_proofs.partial_proofs[0])
+    farmer.pending_solver_requests[key] = {
+        "proof_data": partial_proofs,
         "peer": harvester_peer,
     }
 
@@ -548,7 +574,8 @@ async def test_solution_response_empty_proof(
         mock_new_proof.assert_not_called()
 
         # verify pending request was removed (cleanup still happens)
-        assert partial_proofs.partial_proofs[0] not in farmer.pending_solver_requests
+        key = bytes(partial_proofs.partial_proofs[0])
+        assert key not in farmer.pending_solver_requests
 
 
 @pytest.mark.anyio
@@ -579,9 +606,14 @@ async def test_v2_partial_proofs_solver_exception(
         challenge_hash=challenge_hash,
         sp_hash=sp_hash,
         plot_identifier="test_plot_id",
-        partial_proofs=[b"test_partial_proof_1"],
+        partial_proofs=[
+            test_partial_proof,
+            test_partial_proof2,
+        ],
         signage_point_index=uint8(0),
         plot_size=uint8(32),
+        plot_id=bytes32.fromhex("abababababababababababababababababababababababababababababababab"),
+        strength=uint8(5),
         pool_public_key=G1Element(),
         pool_contract_puzzle_hash=bytes32(b"4" * 32),
         plot_public_key=G1Element(),
@@ -594,4 +626,5 @@ async def test_v2_partial_proofs_solver_exception(
         await farmer_api.partial_proofs(partial_proofs, harvester_peer)
 
         # verify pending request was cleaned up after exception
-        assert partial_proofs.partial_proofs[0] not in farmer.pending_solver_requests
+        key = bytes(partial_proofs.partial_proofs[0])
+        assert key not in farmer.pending_solver_requests

chia/_tests/farmer_harvester/test_filter_prefix_bits.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs import FullBlock
@@ -55,33 +55,33 @@ async def farmer_harvester_with_filter_size_9(
     async def have_connections() -> bool:
         return len(await farmer_rpc_cl.get_connections()) > 0
 
-    local_b_tools = await create_block_tools_async(
+    async with create_block_tools_async(
         constants=test_constants.replace(NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(9)), keychain=get_temp_keyring
-    )
-    new_config = local_b_tools._config
-    local_b_tools.change_config(new_config)
-    async with setup_farmer_solver_multi_harvester(
-        local_b_tools, 1, tmp_path, local_b_tools.constants, start_services=True
-    ) as (harvesters, farmer_service, _):
-        harvester_service = harvesters[0]
-        assert farmer_service.rpc_server is not None
-        farmer_rpc_cl = await FarmerRpcClient.create(
-            self_hostname, farmer_service.rpc_server.listen_port, farmer_service.root_path, farmer_service.config
-        )
-        assert harvester_service.rpc_server is not None
-        harvester_rpc_cl = await HarvesterRpcClient.create(
-            self_hostname,
-            harvester_service.rpc_server.listen_port,
-            harvester_service.root_path,
-            harvester_service.config,
-        )
-        await time_out_assert(15, have_connections, True)
-        yield harvester_service, farmer_service._api
+    ) as local_b_tools:
+        new_config = local_b_tools._config
+        local_b_tools.change_config(new_config)
+        async with setup_farmer_solver_multi_harvester(
+            local_b_tools, 1, tmp_path, local_b_tools.constants, start_services=True
+        ) as (harvesters, farmer_service, _):
+            harvester_service = harvesters[0]
+            assert farmer_service.rpc_server is not None
+            farmer_rpc_cl = await FarmerRpcClient.create(
+                self_hostname, farmer_service.rpc_server.listen_port, farmer_service.root_path, farmer_service.config
+            )
+            assert harvester_service.rpc_server is not None
+            harvester_rpc_cl = await HarvesterRpcClient.create(
+                self_hostname,
+                harvester_service.rpc_server.listen_port,
+                harvester_service.root_path,
+                harvester_service.config,
+            )
+            await time_out_assert(15, have_connections, True)
+            yield harvester_service, farmer_service._api
 
-    farmer_rpc_cl.close()
-    harvester_rpc_cl.close()
-    await farmer_rpc_cl.await_closed()
-    await harvester_rpc_cl.await_closed()
+            farmer_rpc_cl.close()
+            harvester_rpc_cl.close()
+            await farmer_rpc_cl.await_closed()
+            await harvester_rpc_cl.await_closed()
 
 
 @pytest.mark.parametrize(argnames=["peak_height", "eligible_plots"], argvalues=[(5495999, 0), (5496000, 1)])
@@ -94,7 +94,7 @@ async def test_filter_prefix_bits_with_farmer_harvester(
     state_change = None
     state_change_data = None
 
-    def state_changed_callback(change: str, change_data: Optional[dict[str, Any]]) -> None:
+    def state_changed_callback(change: str, change_data: dict[str, Any] | None) -> None:
         nonlocal state_change, state_change_data
         state_change = change
         state_change_data = change_data