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

chia/_tests/core/daemon/test_daemon.py

@@ -5,7 +5,7 @@ import json
 import logging
 from dataclasses import dataclass, field, replace
 from pathlib import Path
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 import aiohttp
 import pytest
@@ -94,7 +94,7 @@ class ChiaPlottersBladebitArgsCase:
     pool_contract: str = "txch1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
     compress: int = 1
     device: int = 0
-    hybrid_disk_mode: Optional[int] = None
+    hybrid_disk_mode: int | None = None
     farmer_pk: str = ""
     final_dir: str = ""
     marks: Marks = ()
@@ -147,7 +147,7 @@ class ChiaPlottersBladebitArgsCase:
 class Service:
     running: bool
 
-    def poll(self) -> Optional[int]:
+    def poll(self) -> int | None:
         return None if self.running else 1
 
 
@@ -155,8 +155,8 @@ class Service:
 @dataclass
 class Daemon:
     # Instance variables used by WebSocketServer.is_running()
-    services: dict[str, Union[list[Service], Service]]
-    connections: dict[str, Optional[list[Any]]]
+    services: dict[str, list[Service] | Service]
+    connections: dict[str, list[Any] | None]
 
     # Instance variables used by WebSocketServer.get_wallet_addresses()
     net_config: dict[str, Any] = field(default_factory=dict)
@@ -314,9 +314,9 @@ label_newline_or_tab_response_data = {
 def assert_response(
     response: aiohttp.http_websocket.WSMessage,
     expected_response_data: dict[str, Any],
-    request_id: Optional[str] = None,
+    request_id: str | None = None,
     ack: bool = True,
-    command: Optional[str] = None,
+    command: str | None = None,
 ) -> None:
     # Expect: JSON response
     assert response.type == aiohttp.WSMsgType.TEXT
@@ -332,7 +332,7 @@ def assert_response(
 
 
 def assert_response_success_only(
-    response: aiohttp.http_websocket.WSMessage, request_id: Optional[str] = None
+    response: aiohttp.http_websocket.WSMessage, request_id: str | None = None
 ) -> dict[str, Any]:
     # Expect: JSON response
     assert response.type == aiohttp.WSMsgType.TEXT
@@ -1015,7 +1015,7 @@ async def test_add_private_key(daemon_connection_and_temp_keychain):
     # Expect: Failure due to missing mnemonic
     assert_response(await ws.receive(), missing_mnemonic_response_data)
 
-    # When: using a mmnemonic with an incorrect word (typo)
+    # When: using a mnemonic with an incorrect word (typo)
     await ws.send_str(create_payload("add_private_key", {"mnemonic": mnemonic_with_typo}, "test", "daemon"))
     # Expect: Failure due to misspelled mnemonic
     assert_response(await ws.receive(), mnemonic_with_typo_response_data)
@@ -1025,7 +1025,7 @@ async def test_add_private_key(daemon_connection_and_temp_keychain):
     # Expect: Failure due to invalid mnemonic
     assert_response(await ws.receive(), invalid_mnemonic_length_response_data)
 
-    # When: using an incorrect mnemnonic
+    # When: using an incorrect mnemonic
     await ws.send_str(create_payload("add_private_key", {"mnemonic": " ".join(["abandon"] * 24)}, "test", "daemon"))
     # Expect: Failure due to checksum error
     assert_response(await ws.receive(), invalid_mnemonic_response_data)
@@ -1340,7 +1340,7 @@ async def test_bad_json(daemon_connection_and_temp_keychain: tuple[aiohttp.Clien
     ),
     RouteCase(
         route="unknown_command",
-        description="non-existant route",
+        description="non-existent route",
         request={},
         response={"success": False, "error": "unknown_command unknown_command"},
     ),

chia/_tests/core/data_layer/conftest.py

@@ -4,8 +4,8 @@ import os
 import pathlib
 import sys
 import time
-from collections.abc import AsyncIterable, Awaitable, Iterator
-from typing import Any, Callable
+from collections.abc import AsyncIterable, Awaitable, Callable, Iterator
+from typing import Any
 
 import pytest
 

chia/_tests/core/data_layer/test_data_rpc.py

@@ -16,7 +16,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from enum import IntEnum
 from pathlib import Path
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import anyio
 import chia_rs.datalayer
@@ -73,7 +73,6 @@ from chia.util.timing import adjusted_timeout, backoff_times
 from chia.wallet.trading.offer import Offer as TradingOffer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
-from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_request_types import CheckOfferValidity, DLLatestSingleton
 from chia.wallet.wallet_rpc_api import WalletRpcApi
@@ -97,10 +96,10 @@ class InterfaceLayer(enum.Enum):
 async def init_data_layer_service(
     wallet_rpc_port: uint16,
     bt: BlockTools,
-    db_path: Optional[Path] = None,
-    wallet_service: Optional[WalletService] = None,
+    db_path: Path | None = None,
+    wallet_service: WalletService | None = None,
     manage_data_interval: int = 5,
-    maximum_full_file_count: Optional[int] = None,
+    maximum_full_file_count: int | None = None,
     enable_batch_autoinsert: bool = True,
     group_files_by_store: bool = False,
 ) -> AsyncIterator[DataLayerService]:
@@ -131,9 +130,9 @@ async def init_data_layer(
     wallet_rpc_port: uint16,
     bt: BlockTools,
     db_path: Path,
-    wallet_service: Optional[WalletService] = None,
+    wallet_service: WalletService | None = None,
     manage_data_interval: int = 5,
-    maximum_full_file_count: Optional[int] = None,
+    maximum_full_file_count: int | None = None,
     group_files_by_store: bool = False,
     enable_batch_autoinsert: bool = True,
 ) -> AsyncIterator[DataLayer]:
@@ -763,6 +762,7 @@ async def test_get_owned_stores(
         ph = await action_scope.get_puzzle_hash(wallet_node.wallet_state_manager)
     for i in range(num_blocks):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+    await full_node_api.wait_for_wallet_synced(wallet_node, timeout=30)
     funds = sum(
         calculate_pool_reward(uint32(i)) + calculate_base_farmer_reward(uint32(i)) for i in range(1, num_blocks)
     )
@@ -777,11 +777,11 @@ async def test_get_owned_stores(
             assert res is not None
             launcher_id = bytes32.from_hexstr(res["id"])
             expected_store_ids.append(launcher_id)
+            await full_node_api.wait_for_wallet_synced(wallet_node)
 
         await time_out_assert(4, check_mempool_spend_count, True, full_node_api, 3)
-        for i in range(num_blocks):
-            await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
-            await asyncio.sleep(0.5)
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+        await full_node_api.wait_for_wallet_synced(wallet_node)
 
         response = await data_rpc_api.get_owned_stores(request={})
         store_ids = sorted(bytes32.from_hexstr(id) for id in response["store_ids"])
@@ -845,6 +845,11 @@ class OfferSetup:
     maker: StoreSetup
     taker: StoreSetup
     full_node_api: FullNodeSimulator
+    wallet_nodes: list[WalletNode]
+
+    async def wait_for_wallets_synced(self, timeout: int = 30) -> None:
+        for node in self.wallet_nodes:
+            await self.full_node_api.wait_for_wallet_synced(wallet_node=node, timeout=timeout)
 
 
 @pytest.fixture(name="offer_setup")
@@ -857,16 +862,17 @@ async def offer_setup_fixture(
     [full_node_service], wallet_services, bt = two_wallet_nodes_services
     enable_batch_autoinsertion_settings = getattr(request, "param", (True, True))
     full_node_api = full_node_service._api
-    wallets: list[Wallet] = []
+    wallets: list[WalletNode] = []
     for wallet_service in wallet_services:
         wallet_node = wallet_service._node
         assert wallet_node.server is not None
         await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_api.server.get_port()), None)
         assert wallet_node.wallet_state_manager is not None
         wallet = wallet_node.wallet_state_manager.main_wallet
-        wallets.append(wallet)
+        wallets.append(wallet_node)
 
         await full_node_api.farm_blocks_to_wallet(count=1, wallet=wallet, timeout=60)
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=30)
 
     async with contextlib.AsyncExitStack() as exit_stack:
         store_setups: list[StoreSetup] = []
@@ -951,6 +957,7 @@ async def offer_setup_fixture(
                 data_rpc_client=taker.data_rpc_client,
             ),
             full_node_api=full_node_api,
+            wallet_nodes=wallets,
         )
 
         maker.data_rpc_client.close()
@@ -1018,6 +1025,7 @@ async def populate_offer_setup(offer_setup: OfferSetup, count: int) -> OfferSetu
             data_rpc_client=offer_setup.taker.data_rpc_client,
         ),
         full_node_api=offer_setup.full_node_api,
+        wallet_nodes=offer_setup.wallet_nodes,
     )
 
 
@@ -1026,7 +1034,7 @@ async def process_for_data_layer_keys(
     full_node_api: FullNodeSimulator,
     data_layer: DataLayer,
     store_id: bytes32,
-    expected_value: Optional[bytes] = None,
+    expected_value: bytes | None = None,
 ) -> None:
     for sleep_time in backoff_times():
         try:
@@ -1843,6 +1851,7 @@ async def test_make_and_cancel_offer(offer_setup: OfferSetup, reference: MakeAnd
     # due to differences in chain progression, the exact offer and trade id may differ from the reference
     # assert maker_response == {"success": True, "offer": reference.make_offer_response}
     assert maker_response["success"] is True
+    await offer_setup.wait_for_wallets_synced()
 
     cancel_request = {
         "trade_id": maker_response["offer"]["trade_id"],
@@ -1865,6 +1874,8 @@ async def test_make_and_cancel_offer(offer_setup: OfferSetup, reference: MakeAnd
     else:  # pragma: no cover
         assert False, "offer was not cancelled"
 
+    await offer_setup.wait_for_wallets_synced()
+
     taker_request = {
         "offer": maker_response["offer"],
         "fee": 0,
@@ -1926,6 +1937,7 @@ async def test_make_and_cancel_offer_then_update(
     # due to differences in chain progression, the exact offer and trade id may differ from the reference
     # assert maker_response == {"success": True, "offer": reference.make_offer_response}
     assert maker_response["success"] is True
+    await offer_setup.wait_for_wallets_synced()
 
     cancel_request = {
         "trade_id": maker_response["offer"]["trade_id"],
@@ -2015,6 +2027,7 @@ async def test_make_and_cancel_offer_not_secure_clears_pending_roots(
     # due to differences in chain progression, the exact offer and trade id may differ from the reference
     # assert maker_response == {"success": True, "offer": reference.make_offer_response}
     assert maker_response["success"] is True
+    await offer_setup.wait_for_wallets_synced()
 
     cancel_request = {
         "trade_id": maker_response["offer"]["trade_id"],
@@ -2568,6 +2581,7 @@ async def populate_proof_setup(offer_setup: OfferSetup, count: int) -> OfferSetu
             data_rpc_client=offer_setup.taker.data_rpc_client,
         ),
         full_node_api=offer_setup.full_node_api,
+        wallet_nodes=offer_setup.wallet_nodes,
     )
 
 
@@ -3054,7 +3068,7 @@ async def test_pagination_cmds(
     one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
     tmp_path: Path,
     layer: InterfaceLayer,
-    max_page_size: Optional[int],
+    max_page_size: int | None,
     bt: BlockTools,
 ) -> None:
     wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(

chia/_tests/core/data_layer/test_data_store.py

@@ -10,12 +10,12 @@ import re
 import shutil
 import statistics
 import time
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from hashlib import sha256
 from pathlib import Path
 from random import Random
-from typing import Any, BinaryIO, Callable, Optional
+from typing import Any, BinaryIO
 
 import aiohttp
 import chia_rs.datalayer
@@ -290,7 +290,7 @@ async def test_get_ancestors_optimized(data_store: DataStore, store_id: bytes32)
     node_count = 0
     node_hashes: list[bytes32] = []
     hash_to_key: dict[bytes32, bytes] = {}
-    node_hash: Optional[bytes32]
+    node_hash: bytes32 | None
 
     for i in range(1000):
         is_insert = False
@@ -1223,7 +1223,7 @@ async def test_server_http_ban(
     async def mock_http_download(
         target_filename_path: Path,
         filename: str,
-        proxy_url: Optional[str],
+        proxy_url: str | None,
         server_info: ServerInfo,
         timeout: aiohttp.ClientTimeout,
         log: logging.Logger,
@@ -1278,7 +1278,7 @@ async def test_server_http_ban(
     assert sinfo.ignore_till == start_timestamp  # we don't increase on second failure
 
 
-async def get_first_generation(data_store: DataStore, node_hash: bytes32, store_id: bytes32) -> Optional[int]:
+async def get_first_generation(data_store: DataStore, node_hash: bytes32, store_id: bytes32) -> int | None:
     async with data_store.db_wrapper.reader() as reader:
         cursor = await reader.execute(
             "SELECT generation FROM nodes WHERE hash = ? AND store_id = ?",
@@ -1301,8 +1301,8 @@ async def write_tree_to_file_old_format(
     node_hash: bytes32,
     store_id: bytes32,
     writer: BinaryIO,
-    merkle_blob: Optional[MerkleBlob] = None,
-    hash_to_index: Optional[dict[bytes32, TreeIndex]] = None,
+    merkle_blob: MerkleBlob | None = None,
+    hash_to_index: dict[bytes32, TreeIndex] | None = None,
 ) -> None:
     if node_hash == bytes32.zeros:
         return
@@ -1760,7 +1760,7 @@ async def test_insert_from_delta_file(
     async def mock_http_download(
         target_filename_path: Path,
         filename: str,
-        proxy_url: Optional[str],
+        proxy_url: str | None,
         server_info: ServerInfo,
         timeout: int,
         log: logging.Logger,
@@ -1770,7 +1770,7 @@ async def test_insert_from_delta_file(
     async def mock_http_download_2(
         target_filename_path: Path,
         filename: str,
-        proxy_url: Optional[str],
+        proxy_url: str | None,
         server_info: ServerInfo,
         timeout: int,
         log: logging.Logger,
@@ -2180,7 +2180,7 @@ async def test_basic_key_value_db_vs_disk_cutoff(
         ) as cursor:
             row = await cursor.fetchone()
             assert row is not None
-            db_blob: Optional[bytes] = row["blob"]
+            db_blob: bytes | None = row["blob"]
 
     if size_offset <= 0:
         assert not file_exists

chia/_tests/core/data_layer/util.py

@@ -8,7 +8,7 @@ import shutil
 import subprocess
 from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import IO, TYPE_CHECKING, Any, Literal, Optional, Union, overload
+from typing import IO, TYPE_CHECKING, Any, Literal, overload
 
 from chia_rs.sized_bytes import bytes32
 
@@ -17,7 +17,7 @@ from chia.data_layer.data_store import DataStore
 from chia.types.blockchain_format.program import Program
 
 # from subprocess.pyi
-_FILE = Union[int, IO[Any], None]
+_FILE = int | IO[Any] | None
 
 
 if TYPE_CHECKING:
@@ -34,8 +34,8 @@ async def general_insert(
     store_id: bytes32,
     key: bytes,
     value: bytes,
-    reference_node_hash: Optional[bytes32],
-    side: Optional[Side],
+    reference_node_hash: bytes32 | None,
+    side: Side | None,
 ) -> bytes32:
     insert_result = await data_store.insert(
         key=key,
@@ -123,12 +123,12 @@ class ChiaRoot:
 
     def run(
         self,
-        args: list[Union[str, os_PathLike_str]],
+        args: list[str | os_PathLike_str],
         *other_args: Any,
         check: bool = True,
         encoding: str = "utf-8",
-        stdout: Optional[_FILE] = subprocess.PIPE,
-        stderr: Optional[_FILE] = subprocess.PIPE,
+        stdout: _FILE | None = subprocess.PIPE,
+        stderr: _FILE | None = subprocess.PIPE,
         **kwargs: Any,
     ) -> subprocess_CompletedProcess_str:
         # TODO: --root-path doesn't seem to work here...
@@ -143,7 +143,7 @@ class ChiaRoot:
         chia_executable = shutil.which("chia")
         if chia_executable is None:
             chia_executable = "chia"
-        modified_args: list[Union[str, os_PathLike_str]] = [
+        modified_args: list[str | os_PathLike_str] = [
             self.scripts_path.joinpath(chia_executable),
             "--root-path",
             self.path,
@@ -166,7 +166,7 @@ class ChiaRoot:
         return self.path.joinpath("log", "debug.log").read_text(encoding="utf-8")
 
     def print_log(self) -> None:
-        log_text: Optional[str]
+        log_text: str | None
 
         try:
             log_text = self.read_log()
@@ -204,8 +204,8 @@ def create_valid_node_values(
 
 def create_valid_node_values(
     node_type: NodeType,
-    left_hash: Optional[bytes32] = None,
-    right_hash: Optional[bytes32] = None,
+    left_hash: bytes32 | None = None,
+    right_hash: bytes32 | None = None,
 ) -> dict[str, Any]:
     if node_type == NodeType.INTERNAL:
         assert left_hash is not None

chia/_tests/core/farmer/test_farmer_api.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from asyncio import Task, gather, sleep
 from collections.abc import Coroutine
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 
 import pytest
 from chia_rs.sized_ints import uint8, uint32, uint64
@@ -80,9 +80,7 @@ async def test_farmer_responds_with_signed_values(farmer_one_harvester: FarmerOn
     )
     setattr(farmer_api, "_process_respond_signatures", lambda res: signed_values)
 
-    signed_values_task: Task[Optional[Message]] = await begin_task(
-        farmer_api.request_signed_values(request_signed_values)
-    )
+    signed_values_task: Task[Message | None] = await begin_task(farmer_api.request_signed_values(request_signed_values))
 
     # Wait a bit for the dummy harvester to receive the signature request and respond with a dummy signature
     await sleep(1)

chia/_tests/core/full_node/full_sync/test_full_sync.py

@@ -24,11 +24,11 @@ log = logging.getLogger(__name__)
 
 @pytest.mark.anyio
 async def test_long_sync_from_zero(
-    five_nodes: list[FullNodeAPI], default_400_blocks: list[FullBlock], bt: BlockTools, self_hostname: str
+    five_nodes: list[FullNodeAPI], default_1000_blocks: list[FullBlock], bt: BlockTools, self_hostname: str
 ) -> None:
     # Must be larger than "sync_block_behind_threshold" in the config
-    num_blocks = len(default_400_blocks)
-    blocks: list[FullBlock] = default_400_blocks
+    blocks: list[FullBlock] = default_1000_blocks[:600]
+    num_blocks = len(blocks)
     full_node_1, full_node_2, full_node_3, full_node_4, full_node_5 = five_nodes
     server_1 = full_node_1.full_node.server
     server_2 = full_node_2.full_node.server
@@ -37,7 +37,7 @@ async def test_long_sync_from_zero(
     server_5 = full_node_5.full_node.server
 
     # If this constant is changed, update the tests to use more blocks
-    assert bt.constants.WEIGHT_PROOF_RECENT_BLOCKS < 400
+    assert bt.constants.WEIGHT_PROOF_RECENT_BLOCKS < num_blocks
 
     # Syncs up less than recent blocks
     for block in blocks[: bt.constants.WEIGHT_PROOF_RECENT_BLOCKS - 5]:
@@ -101,14 +101,14 @@ async def test_long_sync_from_zero(
     await time_out_assert(timeout_seconds, node_height_exactly, True, full_node_4, num_blocks - 1)
 
     # Deep reorg, fall back from batch sync to long sync
-    blocks_node_5 = bt.get_consecutive_blocks(60, block_list_input=blocks[:350], seed=b"node5")
+    blocks_node_5 = bt.get_consecutive_blocks(250, block_list_input=blocks[:350], seed=b"node5")
     for block in blocks_node_5:
         await full_node_5.full_node.add_block(block)
     await server_5.start_client(
         PeerInfo(self_hostname, server_1.get_port()), on_connect=full_node_5.full_node.on_connect
     )
-    await time_out_assert(timeout_seconds, node_height_exactly, True, full_node_5, 409)
-    await time_out_assert(timeout_seconds, node_height_exactly, True, full_node_1, 409)
+    await time_out_assert(timeout_seconds, node_height_exactly, True, full_node_5, 250 + 350 - 1)
+    await time_out_assert(timeout_seconds, node_height_exactly, True, full_node_1, 250 + 350 - 1)
 
 
 @pytest.mark.anyio
@@ -384,6 +384,7 @@ async def test_block_ses_mismatch(
             s.num_blocks_overflow,
             uint64(s.new_difficulty * 2) if s.new_difficulty is not None else None,
             uint64(s.new_sub_slot_iters * 2) if s.new_sub_slot_iters is not None else None,
+            None,
         )
         # manually try sync with wrong sub epoch summary list
         await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), None)

chia/_tests/core/full_node/stores/test_block_store.py

@@ -5,7 +5,7 @@ import logging
 import random
 import sqlite3
 from pathlib import Path
-from typing import Optional, cast
+from typing import cast
 
 import pytest
 
@@ -16,6 +16,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia._tests.core.full_node.test_full_node import find_reward_coin
 from chia._tests.util.db_connection import DBConnection, PathDBConnection
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_height_map import BlockHeightMap
@@ -41,7 +42,7 @@ def use_cache(request: SubRequest) -> bool:
     return cast(bool, request.param)
 
 
-def maybe_serialize(gen: Optional[SerializedProgram]) -> Optional[bytes]:
+def maybe_serialize(gen: SerializedProgram | None) -> bytes | None:
     if gen is None:
         return None
     else:
@@ -57,11 +58,11 @@ async def test_block_store(tmp_dir: Path, db_version: int, bt: BlockTools, use_c
         3,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=bt.pool_ph,
-        pool_reward_puzzle_hash=bt.pool_ph,
         time_per_block=10,
     )
     wt: WalletTool = bt.get_pool_wallet_tool()
-    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0])
+    coin = find_reward_coin(blocks[-1], bt.pool_ph)
+    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), coin)
     blocks = bt.get_consecutive_blocks(
         10,
         block_list_input=blocks,

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Optional
 
 import aiosqlite
 import pytest
-from chia_rs import CoinState, FullBlock, additions_and_removals, get_flags_for_height_and_constants
+from chia_rs import CoinRecord, CoinState, FullBlock, additions_and_removals, get_flags_for_height_and_constants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -26,7 +25,6 @@ from chia.full_node.hint_store import HintStore
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.simulator.wallet_tools import WalletTool
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_record import CoinRecord
 from chia.types.mempool_item import UnspentLineageInfo
 from chia.util.casts import int_to_bytes
 from chia.util.db_wrapper import DBWrapper2
@@ -68,7 +66,6 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
         10,
         [],
         farmer_reward_puzzle_hash=reward_ph,
-        pool_reward_puzzle_hash=reward_ph,
     )
 
     coins_to_spend: list[Coin] = []
@@ -87,7 +84,6 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
             10,
             blocks,
             farmer_reward_puzzle_hash=reward_ph,
-            pool_reward_puzzle_hash=reward_ph,
             transaction_data=spend_bundle,
         )
 
@@ -236,7 +232,7 @@ async def test_rollback(db_version: int, bt: BlockTools) -> None:
     async with DBConnection(db_version) as db_wrapper:
         coin_store = await CoinStore.create(db_wrapper)
 
-        selected_coin: Optional[CoinRecord] = None
+        selected_coin: CoinRecord | None = None
         all_coins: list[Coin] = []
 
         for block in blocks:
@@ -320,7 +316,7 @@ async def test_basic_reorg(tmp_dir: Path, db_version: int, bt: BlockTools) -> No
         height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
         b: Blockchain = await Blockchain.create(coin_store, store, height_map, bt.constants, 2)
         try:
-            records: list[Optional[CoinRecord]] = []
+            records: list[CoinRecord | None] = []
 
             for block in blocks:
                 await _validate_and_add_block(b, block)
@@ -375,11 +371,9 @@ async def test_get_puzzle_hash(tmp_dir: Path, db_version: int, bt: BlockTools) -
     async with DBConnection(db_version) as db_wrapper:
         num_blocks = 20
         farmer_ph = bytes32(32 * b"0")
-        pool_ph = bytes32(32 * b"1")
         blocks = bt.get_consecutive_blocks(
             num_blocks,
             farmer_reward_puzzle_hash=farmer_ph,
-            pool_reward_puzzle_hash=pool_ph,
             guarantee_transaction_block=True,
         )
         coin_store = await CoinStore.create(db_wrapper)
@@ -392,7 +386,7 @@ async def test_get_puzzle_hash(tmp_dir: Path, db_version: int, bt: BlockTools) -
         assert peak is not None
         assert peak.height == num_blocks - 1
 
-        coins_farmer = await coin_store.get_coin_records_by_puzzle_hash(True, pool_ph)
+        coins_farmer = await coin_store.get_coin_records_by_puzzle_hash(True, bt.pool_ph)
         coins_pool = await coin_store.get_coin_records_by_puzzle_hash(True, farmer_ph)
 
         assert len(coins_farmer) == num_blocks - 2
@@ -570,7 +564,7 @@ async def test_coin_state_batches(
                 continue
             expected_crs.append(cr)
 
-        height: Optional[uint32] = uint32(0)
+        height: uint32 | None = uint32(0)
         all_coin_states: list[CoinState] = []
         remaining_phs = random_coin_records.puzzle_hashes.copy()
 

chia/_tests/core/full_node/stores/test_full_node_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import logging
 import random
 from collections.abc import AsyncIterator
-from typing import Optional
 
 import pytest
 from chia_rs import ConsensusConstants, FullBlock, UnfinishedBlock
@@ -39,7 +38,8 @@ async def custom_block_tools(blockchain_constants: ConsensusConstants) -> AsyncI
             DISCRIMINANT_SIZE_BITS=uint16(32),
             SUB_SLOT_ITERS_STARTING=uint64(2**12),
         )
-        yield await create_block_tools_async(constants=patched_constants, keychain=keychain)
+        async with create_block_tools_async(constants=patched_constants, keychain=keychain) as bt:
+            yield bt
 
 
 @pytest.fixture(scope="function")
@@ -128,15 +128,15 @@ async def test_unfinished_block_rank(
 )
 async def test_find_best_block(
     seeded_random: random.Random,
-    blocks: list[tuple[Optional[int], bool]],
-    expected: Optional[int],
+    blocks: list[tuple[int | None, bool]],
+    expected: int | None,
     default_400_blocks: list[FullBlock],
     bt: BlockTools,
 ) -> None:
-    result: dict[Optional[bytes32], UnfinishedBlockEntry] = {}
+    result: dict[bytes32 | None, UnfinishedBlockEntry] = {}
     i = 0
     for b, with_unf in blocks:
-        unf: Optional[UnfinishedBlock]
+        unf: UnfinishedBlock | None
         if with_unf:
             unf = make_unfinished_block(default_400_blocks[i], bt.constants)
             i += 1
@@ -1022,10 +1022,10 @@ async def test_basic_store(
             and i1 > (i2 + 3)
         ):
             # We hit all the conditions that we want
-            all_sps: list[Optional[SignagePoint]] = [None] * custom_block_tools.constants.NUM_SPS_SUB_SLOT
+            all_sps: list[SignagePoint | None] = [None] * custom_block_tools.constants.NUM_SPS_SUB_SLOT
 
             def assert_sp_none(sp_index: int, is_none: bool) -> None:
-                sp_to_check: Optional[SignagePoint] = all_sps[sp_index]
+                sp_to_check: SignagePoint | None = all_sps[sp_index]
                 assert sp_to_check is not None
                 assert sp_to_check.cc_vdf is not None
                 fetched = store.get_signage_point(sp_to_check.cc_vdf.output.get_hash())