chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/core/test_cost_calculation.py

@@ -2,18 +2,19 @@ from __future__ import annotations
 
 import logging
 import pathlib
-from typing import List
 
 import pytest
 from chia_rs import G1Element
 from clvm_tools import binutils
 
+from chia._tests.core.make_block_generator import make_block_generator
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.misc import BenchmarkRunner
 from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions, get_puzzle_and_solution_for_coin
+from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -23,8 +24,6 @@ from chia.types.generator_types import BlockGenerator
 from chia.util.ints import uint32, uint64
 from chia.wallet.puzzles import p2_delegated_puzzle_or_hidden_puzzle
 
-from .make_block_generator import make_block_generator
-
 BURN_PUZZLE_HASH = bytes32(b"0" * 32)
 SMALL_BLOCK_GENERATOR = make_block_generator(1)
 
@@ -277,7 +276,7 @@ async def test_standard_tx(benchmark_runner: BenchmarkRunner) -> None:
     with benchmark_runner.assert_runtime(seconds=0.1):
         total_cost = 0
         for i in range(0, 1000):
-            cost, result = puzzle_program.run_with_cost(test_constants.MAX_BLOCK_COST_CLVM, solution_program)
+            cost, _result = puzzle_program.run_with_cost(test_constants.MAX_BLOCK_COST_CLVM, solution_program)
             total_cost += cost
 
 
@@ -293,7 +292,7 @@ async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: Be
     )
 
     coin_spends = result.first()
-    spent_coins: List[Coin] = []
+    spent_coins: list[Coin] = []
     for spend in coin_spends.as_iter():
         parent, puzzle, amount_program, _ = spend.as_iter()
         parent_coin_info = parent.as_atom()

chia/_tests/core/test_crawler.py

@@ -58,7 +58,7 @@ async def test_unknown_messages(
         return "Non existing function: request_children" in caplog.text
 
     with caplog.at_level(logging.ERROR):
-        msg = make_msg(ProtocolMessageTypes.request_children, RequestChildren(bytes32(b"\0" * 32)))
+        msg = make_msg(ProtocolMessageTypes.request_children, RequestChildren(bytes32.zeros))
         assert await connection.send_message(msg)
         await time_out_assert(10, receiving_failed)
 
@@ -83,7 +83,7 @@ async def test_valid_message(
 
     msg = make_msg(
         ProtocolMessageTypes.new_peak,
-        NewPeak(bytes32(b"\0" * 32), uint32(2), uint128(1), uint32(1), bytes32(b"\1" * 32)),
+        NewPeak(bytes32.zeros, uint32(2), uint128(1), uint32(1), bytes32(b"\1" * 32)),
     )
     assert await connection.send_message(msg)
     await time_out_assert(10, peer_added)

chia/_tests/core/test_db_conversion.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import random
 from pathlib import Path
-from typing import List, Tuple
 
 import pytest
 
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_upgrade_func import convert_v1_to_v2
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.multiprocess_validation import PreValidationResult
 from chia.full_node.block_store import BlockStore
@@ -32,7 +32,7 @@ def rand_bytes(num) -> bytes:
 async def test_blocks(default_1000_blocks, with_hints: bool):
     blocks = default_1000_blocks
 
-    hints: List[Tuple[bytes32, bytes]] = []
+    hints: list[tuple[bytes32, bytes]] = []
     for i in range(351):
         hints.append((bytes32(rand_bytes(32)), rand_bytes(20)))
 
@@ -74,8 +74,9 @@ async def test_blocks(default_1000_blocks, with_hints: bool):
                     if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
                         sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
                 # await _validate_and_add_block(bc, block)
-                results = PreValidationResult(None, uint64(1), None, False, uint32(0))
-                result, err, _ = await bc.add_block(block, results, None, sub_slot_iters=sub_slot_iters)
+                results = PreValidationResult(None, uint64(1), None, uint32(0))
+                fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+                _, err, _ = await bc.add_block(block, results, sub_slot_iters=sub_slot_iters, fork_info=fork_info)
                 assert err is None
 
         # now, convert v1 in_file to v2 out_file

chia/_tests/core/test_db_validation.py

@@ -4,12 +4,12 @@ import random
 import sqlite3
 from contextlib import closing
 from pathlib import Path
-from typing import List
 
 import pytest
 
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_validate_func import validate_v2
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.multiprocess_validation import PreValidationResult
@@ -128,7 +128,7 @@ def test_db_validate_in_main_chain(invalid_in_chain: bool) -> None:
             validate_v2(db_file, validate_blocks=False)
 
 
-async def make_db(db_file: Path, blocks: List[FullBlock]) -> None:
+async def make_db(db_file: Path, blocks: list[FullBlock]) -> None:
     async with DBWrapper2.managed(database=db_file, reader_count=1, db_version=2) as db_wrapper:
         async with db_wrapper.writer_maybe_transaction() as conn:
             # this is done by chia init normally
@@ -144,13 +144,14 @@ async def make_db(db_file: Path, blocks: List[FullBlock]) -> None:
             if block.height != 0 and len(block.finished_sub_slots) > 0:
                 if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
                     sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
-            results = PreValidationResult(None, uint64(1), None, False, uint32(0))
-            result, err, _ = await bc.add_block(block, results, None, sub_slot_iters=sub_slot_iters)
+            results = PreValidationResult(None, uint64(1), None, uint32(0))
+            fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+            _, err, _ = await bc.add_block(block, results, sub_slot_iters=sub_slot_iters, fork_info=fork_info)
             assert err is None
 
 
 @pytest.mark.anyio
-async def test_db_validate_default_1000_blocks(default_1000_blocks: List[FullBlock]) -> None:
+async def test_db_validate_default_1000_blocks(default_1000_blocks: list[FullBlock]) -> None:
     with TempFile() as db_file:
         await make_db(db_file, default_1000_blocks)
 

chia/_tests/core/test_farmer_harvester_rpc.py

@@ -5,11 +5,12 @@ import logging
 import operator
 import sys
 import time
+from collections.abc import Awaitable
 from math import ceil
 from os import mkdir
 from pathlib import Path
 from shutil import copy
-from typing import Any, Awaitable, Callable, Dict, List, Union, cast
+from typing import Any, Callable, Union, cast
 
 import pytest
 
@@ -46,7 +47,7 @@ log = logging.getLogger(__name__)
 async def wait_for_plot_sync(receiver: Receiver, previous_last_sync_id: uint64) -> None:
     def wait() -> bool:
         current_last_sync_id = receiver.last_sync().sync_id
-        return current_last_sync_id != 0 and current_last_sync_id != previous_last_sync_id
+        return current_last_sync_id not in {0, previous_last_sync_id}
 
     await time_out_assert(30, wait)
 
@@ -358,8 +359,8 @@ def test_plot_matches_filter(filter_item: FilterItem, match: bool) -> None:
 @pytest.mark.skipif(sys.platform == "win32", reason="avoiding crashes on windows until we fix this (crashing workers)")
 async def test_farmer_get_harvester_plots_endpoints(
     harvester_farmer_environment: HarvesterFarmerEnvironment,
-    endpoint: Callable[[FarmerRpcClient, PaginatedRequestData], Awaitable[Dict[str, Any]]],
-    filtering: Union[List[FilterItem], List[str]],
+    endpoint: Callable[[FarmerRpcClient, PaginatedRequestData], Awaitable[dict[str, Any]]],
+    filtering: Union[list[FilterItem], list[str]],
     sort_key: str,
     reverse: bool,
     expected_plot_count: int,
@@ -378,12 +379,12 @@ async def test_farmer_get_harvester_plots_endpoints(
     request: PaginatedRequestData
     if endpoint == FarmerRpcClient.get_harvester_plots_valid:
         request = PlotInfoRequestData(
-            harvester_id, uint32(0), uint32(0), cast(List[FilterItem], filtering), sort_key, reverse
+            harvester_id, uint32(0), uint32(0), cast(list[FilterItem], filtering), sort_key, reverse
         )
     else:
-        request = PlotPathRequestData(harvester_id, uint32(0), uint32(0), cast(List[str], filtering), reverse)
+        request = PlotPathRequestData(harvester_id, uint32(0), uint32(0), cast(list[str], filtering), reverse)
 
-    def add_plot_directories(prefix: str, count: int) -> List[Path]:
+    def add_plot_directories(prefix: str, count: int) -> list[Path]:
         new_paths = []
         for i in range(count):
             new_paths.append(harvester.root_path / f"{prefix}_{i}")

chia/_tests/core/test_filter.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 from chiabip158 import PyBIP158
 
 
 @pytest.mark.anyio
 async def test_basic_filter_test(simulator_and_wallet):
-    full_nodes, wallets, bt = simulator_and_wallet
-    wallet_node, server_2 = wallets[0]
+    _full_nodes, wallets, bt = simulator_and_wallet
+    wallet_node, _server_2 = wallets[0]
     wallet = wallet_node.wallet_state_manager.main_wallet
 
     num_blocks = 2
@@ -21,7 +19,7 @@ async def test_basic_filter_test(simulator_and_wallet):
         pool_reward_puzzle_hash=ph,
     )
     for i in range(1, num_blocks):
-        byte_array_tx: List[bytes] = []
+        byte_array_tx: list[bytes] = []
         block = blocks[i]
         coins = block.get_included_reward_coins()
         coin_0 = bytearray(coins[0].puzzle_hash)

chia/_tests/core/test_full_node_rpc.py

@@ -1,15 +1,11 @@
-# flake8: noqa: F811, F401
 from __future__ import annotations
 
-from typing import List
-
 import pytest
 from chia_rs import AugSchemeMPL
 from clvm.casts import int_to_bytes
 
 from chia import __version__
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
-from chia._tests.conftest import ConsensusMode
 from chia._tests.connection_utils import connect_and_get_peer
 from chia._tests.util.rpc import validate_get_routes
 from chia._tests.util.time_out_assert import time_out_assert
@@ -20,6 +16,7 @@ from chia.protocols import full_node_protocol
 from chia.rpc.full_node_rpc_api import get_average_block_time, get_nearest_transaction_block
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.server.outbound_message import NodeType
+from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import get_signage_point
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol, ReorgProtocol
 from chia.simulator.wallet_tools import WalletTool
@@ -45,13 +42,12 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
     full_node_api_2 = full_node_service_2._api
     server_2 = full_node_api_2.full_node.server
 
-    try:
-        client = await FullNodeRpcClient.create(
-            self_hostname,
-            full_node_service_1.rpc_server.listen_port,
-            full_node_service_1.root_path,
-            full_node_service_1.config,
-        )
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service_1.rpc_server.listen_port,
+        full_node_service_1.root_path,
+        full_node_service_1.config,
+    ) as client:
         await validate_get_routes(client, full_node_service_1.rpc_server.rpc_api)
         state = await client.get_blockchain_state()
         assert state["peak"] is None
@@ -98,20 +94,22 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
 
         assert (await client.get_block_record_by_height(100)) is None
 
-        # TODO: Understand why the list(set()) is required to make this work and address it.  This shouldn't be needed.
-        ph = list(set(blocks[-1].get_included_reward_coins()))[0].puzzle_hash
+        # NOTE: indexing and hard coded values below depend on the ordering
+        included_reward_coins = sorted(blocks[-1].get_included_reward_coins(), key=lambda c: c.amount)
+
+        ph = included_reward_coins[0].puzzle_hash
         coins = await client.get_coin_records_by_puzzle_hash(ph)
         print(coins)
         assert len(coins) >= 1
 
-        pid = list(set(blocks[-1].get_included_reward_coins()))[0].parent_coin_info
-        pid_2 = list(set(blocks[-1].get_included_reward_coins()))[1].parent_coin_info
+        pid = included_reward_coins[0].parent_coin_info
+        pid_2 = included_reward_coins[1].parent_coin_info
         coins = await client.get_coin_records_by_parent_ids([pid, pid_2])
         print(coins)
         assert len(coins) == 2
 
-        name = list(set(blocks[-1].get_included_reward_coins()))[0].name()
-        name_2 = list(set(blocks[-1].get_included_reward_coins()))[1].name()
+        name = included_reward_coins[0].name()
+        name_2 = included_reward_coins[1].name()
         coins = await client.get_coin_records_by_names([name, name_2])
         print(coins)
         assert len(coins) == 2
@@ -139,7 +137,10 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         assert len(await client.get_coin_records_by_puzzle_hash(ph)) == 2
         assert len(await client.get_coin_records_by_puzzle_hash(ph_receiver)) == 0
 
-        coin_to_spend = list(set(blocks[-1].get_included_reward_coins()))[0]
+        # NOTE: indexing and hard coded values below depend on the ordering
+        included_reward_coins = sorted(blocks[-1].get_included_reward_coins(), key=lambda c: c.amount)
+
+        coin_to_spend = included_reward_coins[0]
 
         spend_bundle = wallet.generate_signed_transaction(coin_to_spend.amount, ph_receiver, coin_to_spend)
 
@@ -154,7 +155,9 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         assert len(await client.get_all_mempool_items()) == 1
         assert len(await client.get_all_mempool_tx_ids()) == 1
         assert (
-            WalletSpendBundle.from_json_dict(list((await client.get_all_mempool_items()).values())[0]["spend_bundle"])
+            WalletSpendBundle.from_json_dict(
+                next(iter((await client.get_all_mempool_items()).values()))["spend_bundle"]
+            )
             == spend_bundle
         )
         assert (await client.get_all_mempool_tx_ids())[0] == spend_bundle.name()
@@ -167,7 +170,7 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         assert (await client.get_coin_record_by_name(coin.name())) is None
 
         # Verify that the include_pending arg to get_mempool_item_by_tx_id works
-        coin_to_spend_pending = list(set(blocks[-1].get_included_reward_coins()))[1]
+        coin_to_spend_pending = included_reward_coins[1]
         ahr = ConditionOpcode.ASSERT_HEIGHT_RELATIVE  # to force pending/potential
         condition_dic = {ahr: [ConditionWithArgs(ahr, [int_to_bytes(100)])]}
         spend_bundle_pending = wallet.generate_signed_transaction(
@@ -216,7 +219,7 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
                 coin_records[i].coin.amount, ph_receiver, coin_records[i].coin
             )
             await client.push_tx(spend_bundle)
-            coin_spends = coin_spends + spend_bundle.coin_spends
+            coin_spends += spend_bundle.coin_spends
             await time_out_assert(
                 5, full_node_api_1.full_node.mempool_manager.get_spendbundle, spend_bundle, spend_bundle.name()
             )
@@ -231,7 +234,7 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         block_spends = await client.get_block_spends(block.header_hash)
 
         assert len(block_spends) == 3
-        assert sorted(block_spends, key=lambda x: str(x)) == sorted(coin_spends, key=lambda x: str(x))
+        assert sorted(block_spends, key=str) == sorted(coin_spends, key=str)
 
         block_spends_with_conditions = await client.get_block_spends_with_conditions(block.header_hash)
 
@@ -361,7 +364,7 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
             state = await client.get_blockchain_state()
             block = await client.get_block(state["peak"].header_hash)
 
-            coin_to_spend = list(set(block.get_included_reward_coins()))[0]
+            coin_to_spend = block.get_included_reward_coins()[0]
 
             spend_bundle = wallet.generate_signed_transaction(coin_to_spend.amount, ph_2, coin_to_spend, memo=memo)
             await client.push_tx(spend_bundle)
@@ -408,25 +411,20 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod
         await client.close_connection(connections[0]["node_id"])
         await time_out_assert(10, num_connections, 0)
 
-        blocks: List[FullBlock] = await client.get_blocks(0, 5)
+        blocks: list[FullBlock] = await client.get_blocks(0, 5)
         assert len(blocks) == 5
 
         await full_node_api_1.reorg_from_index_to_new_index(ReorgProtocol(2, 55, bytes([0x2] * 32), None))
-        new_blocks_0: List[FullBlock] = await client.get_blocks(0, 5)
+        new_blocks_0: list[FullBlock] = await client.get_blocks(0, 5)
         assert len(new_blocks_0) == 7
 
-        new_blocks: List[FullBlock] = await client.get_blocks(0, 5, exclude_reorged=True)
+        new_blocks: list[FullBlock] = await client.get_blocks(0, 5, exclude_reorged=True)
         assert len(new_blocks) == 5
         assert blocks[0].header_hash == new_blocks[0].header_hash
         assert blocks[1].header_hash == new_blocks[1].header_hash
         assert blocks[2].header_hash == new_blocks[2].header_hash
         assert blocks[3].header_hash != new_blocks[3].header_hash
 
-    finally:
-        # Checks that the RPC manages to stop the node
-        client.close()
-        await client.await_closed()
-
 
 @pytest.mark.anyio
 async def test_signage_points(two_nodes_sim_and_wallets_services, empty_blockchain):
@@ -442,14 +440,12 @@ async def test_signage_points(two_nodes_sim_and_wallets_services, empty_blockcha
 
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
 
-    try:
-        client = await FullNodeRpcClient.create(
-            self_hostname,
-            full_node_service_1.rpc_server.listen_port,
-            full_node_service_1.root_path,
-            full_node_service_1.config,
-        )
-
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service_1.rpc_server.listen_port,
+        full_node_service_1.root_path,
+        full_node_service_1.config,
+    ) as client:
         # Only provide one
         res = await client.get_recent_signage_point_or_eos(None, None)
         assert res is None
@@ -537,8 +533,7 @@ async def test_signage_points(two_nodes_sim_and_wallets_services, empty_blockcha
 
         # Perform a reorg
         blocks = bt.get_consecutive_blocks(12, seed=b"1234")
-        for block in blocks:
-            await full_node_api_1.full_node.add_block(block)
+        await add_blocks_in_batches(blocks, full_node_api_1.full_node)
 
         # Signage point is no longer in the blockchain
         res = await client.get_recent_signage_point_or_eos(sp.cc_vdf.output.get_hash(), None)
@@ -553,15 +548,10 @@ async def test_signage_points(two_nodes_sim_and_wallets_services, empty_blockcha
         assert res["eos"] == selected_eos
         assert res["reverted"]
 
-    finally:
-        # Checks that the RPC manages to stop the node
-        client.close()
-        await client.await_closed()
-
 
 @pytest.mark.anyio
 async def test_get_network_info(one_wallet_and_one_simulator_services, self_hostname):
-    nodes, _, bt = one_wallet_and_one_simulator_services
+    nodes, _, _bt = one_wallet_and_one_simulator_services
     (full_node_service_1,) = nodes
 
     async with FullNodeRpcClient.create_as_context(
@@ -582,7 +572,7 @@ async def test_get_network_info(one_wallet_and_one_simulator_services, self_host
 
 @pytest.mark.anyio
 async def test_get_version(one_wallet_and_one_simulator_services, self_hostname):
-    nodes, _, bt = one_wallet_and_one_simulator_services
+    nodes, _, _bt = one_wallet_and_one_simulator_services
     (full_node_service_1,) = nodes
     async with FullNodeRpcClient.create_as_context(
         self_hostname,
@@ -620,7 +610,7 @@ async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_
         assert state["space"] == 0
         assert state["average_block_time"] is None
 
-        blocks: List[FullBlock] = bt.get_consecutive_blocks(num_blocks)
+        blocks: list[FullBlock] = bt.get_consecutive_blocks(num_blocks)
         blocks = bt.get_consecutive_blocks(num_blocks, block_list_input=blocks, guarantee_transaction_block=True)
 
         for block in blocks:
@@ -643,7 +633,7 @@ async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_
         assert state["space"] > 0
         assert state["average_block_time"] > 0
 
-        block_records: List[BlockRecord] = [
+        block_records: list[BlockRecord] = [
             await full_node_api_1.full_node.blockchain.get_block_record_from_db(rec.header_hash) for rec in blocks
         ]
         first_non_transaction_block_index = -1
@@ -655,8 +645,8 @@ async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_
         # so first_non_transaction_block_index != 0
         assert first_non_transaction_block_index > 0
 
-        transaction_blocks: List[BlockRecord] = [b for b in block_records if b.is_transaction_block]
-        non_transaction_block: List[BlockRecord] = [b for b in block_records if not b.is_transaction_block]
+        transaction_blocks: list[BlockRecord] = [b for b in block_records if b.is_transaction_block]
+        non_transaction_block: list[BlockRecord] = [b for b in block_records if not b.is_transaction_block]
         assert len(transaction_blocks) > 0
         assert len(non_transaction_block) > 0
         assert transaction_blocks[0] == await get_nearest_transaction_block(
@@ -686,41 +676,31 @@ async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_
 async def test_coin_name_not_in_request(one_node, self_hostname):
     [full_node_service], _, _ = one_node
 
-    try:
-        client = await FullNodeRpcClient.create(
-            self_hostname,
-            full_node_service.rpc_server.listen_port,
-            full_node_service.root_path,
-            full_node_service.config,
-        )
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service.rpc_server.listen_port,
+        full_node_service.root_path,
+        full_node_service.config,
+    ) as client:
         with pytest.raises(ValueError, match="No coin_name in request"):
             await client.fetch("get_mempool_items_by_coin_name", {})
-    finally:
-        # Checks that the RPC manages to stop the node
-        client.close()
-        await client.await_closed()
 
 
 @pytest.mark.anyio
 async def test_coin_name_not_found_in_mempool(one_node, self_hostname):
     [full_node_service], _, _ = one_node
 
-    try:
-        client = await FullNodeRpcClient.create(
-            self_hostname,
-            full_node_service.rpc_server.listen_port,
-            full_node_service.root_path,
-            full_node_service.config,
-        )
-
-        empty_coin_name = bytes32([0] * 32)
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service.rpc_server.listen_port,
+        full_node_service.root_path,
+        full_node_service.config,
+    ) as client:
+        empty_coin_name = bytes32.zeros
         mempool_item = await client.get_mempool_items_by_coin_name(empty_coin_name)
-        assert mempool_item["success"] == True
+        assert mempool_item["success"]
         assert "mempool_items" in mempool_item
         assert len(mempool_item["mempool_items"]) == 0
-    finally:
-        client.close()
-        await client.await_closed()
 
 
 @pytest.mark.anyio
@@ -728,14 +708,12 @@ async def test_coin_name_found_in_mempool(one_node, self_hostname):
     [full_node_service], _, bt = one_node
     full_node_api = full_node_service._api
 
-    try:
-        client = await FullNodeRpcClient.create(
-            self_hostname,
-            full_node_service.rpc_server.listen_port,
-            full_node_service.root_path,
-            full_node_service.config,
-        )
-
+    async with FullNodeRpcClient.create_as_context(
+        self_hostname,
+        full_node_service.rpc_server.listen_port,
+        full_node_service.root_path,
+        full_node_service.config,
+    ) as client:
         blocks = bt.get_consecutive_blocks(2)
         blocks = bt.get_consecutive_blocks(2, block_list_input=blocks, guarantee_transaction_block=True)
 
@@ -772,7 +750,7 @@ async def test_coin_name_found_in_mempool(one_node, self_hostname):
         # empty mempool
         assert len(await client.get_all_mempool_items()) == 0
 
-        coin_to_spend = list(set(blocks[-1].get_included_reward_coins()))[0]
+        coin_to_spend = blocks[-1].get_included_reward_coins()[0]
         spend_bundle = wallet.generate_signed_transaction(coin_to_spend.amount, ph_receiver, coin_to_spend)
         await client.push_tx(spend_bundle)
 
@@ -782,13 +760,9 @@ async def test_coin_name_found_in_mempool(one_node, self_hostname):
         mempool_item = await client.get_mempool_items_by_coin_name(coin_to_spend.name())
 
         # found coin in coin spends
-        assert mempool_item["success"] == True
+        assert mempool_item["success"]
         assert "mempool_items" in mempool_item
         assert len(mempool_item["mempool_items"]) > 0
         for item in mempool_item["mempool_items"]:
             removals = [Coin.from_json_dict(coin) for coin in item["removals"]]
             assert coin_to_spend.name() in [coin.name() for coin in removals]
-
-    finally:
-        client.close()
-        await client.await_closed()

chia/_tests/core/test_merkle_set.py

@@ -5,7 +5,7 @@ import random
 from hashlib import sha256
 from itertools import permutations
 from random import Random
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import Coin, MerkleSet, compute_merkle_set_root, confirm_included_already_hashed
@@ -93,7 +93,7 @@ async def test_merkle_set_duplicate() -> None:
 async def test_merkle_set_0() -> None:
     merkle_set = MerkleSet([])
     assert merkle_set.get_root() == bytes32(compute_merkle_set_root([]))
-    assert merkle_set.get_root() == bytes32([0] * 32)
+    assert merkle_set.get_root() == bytes32.zeros
 
 
 @pytest.mark.anyio
@@ -155,7 +155,7 @@ async def test_merkle_set_4() -> None:
 
 @pytest.mark.anyio
 async def test_merkle_set_5() -> None:
-    BLANK = bytes32([0] * 32)
+    BLANK = bytes32.zeros
 
     a = bytes32([0x58] + [0] * 31)
     b = bytes32([0x23] + [0] * 31)
@@ -202,7 +202,7 @@ async def test_merkle_set_5() -> None:
 
 @pytest.mark.anyio
 async def test_merkle_left_edge() -> None:
-    BLANK = bytes32([0] * 32)
+    BLANK = bytes32.zeros
     a = bytes32([0x80] + [0] * 31)
     b = bytes32([0] * 31 + [1])
     c = bytes32([0] * 31 + [2])
@@ -241,7 +241,7 @@ async def test_merkle_left_edge() -> None:
 
 @pytest.mark.anyio
 async def test_merkle_right_edge() -> None:
-    BLANK = bytes32([0] * 32)
+    BLANK = bytes32.zeros
     a = bytes32([0x40] + [0] * 31)
     b = bytes32([0xFF] * 31 + [0xFF])
     c = bytes32([0xFF] * 31 + [0xFE])
@@ -292,7 +292,7 @@ async def test_merkle_set_random_regression() -> None:
     rng.seed(123456)
     for i in range(100):
         size = rng.randint(0, 4000)
-        values: List[bytes32] = [rand_hash(rng) for _ in range(size)]
+        values: list[bytes32] = [rand_hash(rng) for _ in range(size)]
         print(f"iter: {i}/100 size: {size}")
 
         for _ in range(10):
@@ -304,7 +304,7 @@ async def test_merkle_set_random_regression() -> None:
             assert rust_root == python_root
 
 
-def make_test_coins(n: int, rng: Random) -> List[Coin]:
+def make_test_coins(n: int, rng: Random) -> list[Coin]:
     return [Coin(bytes32.random(rng), bytes32.random(rng), uint64(rng.randint(0, 10000000))) for i in range(n)]
 
 
@@ -314,7 +314,7 @@ def test_validate_removals_full_list(num_coins: int, seeded_random: Random) -> N
     # the root can be computed by all the removals
     coins = make_test_coins(num_coins, seeded_random)
 
-    coin_map: List[Tuple[bytes32, Optional[Coin]]] = []
+    coin_map: list[tuple[bytes32, Optional[Coin]]] = []
     removals_merkle_set = MerkleSet([coin.name() for coin in coins])
     for coin in coins:
         coin_map.append((coin.name(), coin))
@@ -330,8 +330,8 @@ def test_validate_additions_full_list(num_coins: int, batch_size: int, seeded_ra
     # the root can be computed by all the removals
     coins = make_test_coins(num_coins, seeded_random)
 
-    additions: List[Tuple[bytes32, List[Coin]]] = []
-    leafs: List[bytes32] = []
+    additions: list[tuple[bytes32, list[Coin]]] = []
+    leafs: list[bytes32] = []
     for coin_batch in to_batches(coins, batch_size):
         puzzle_hash = bytes32.random(seeded_random)
         additions.append((puzzle_hash, coin_batch.entries))

chia/_tests/core/test_program.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import List
-
 from clvm.SExp import CastableType
 from clvm_tools import binutils
 
@@ -25,8 +23,8 @@ def program_roundtrip(o: CastableType) -> None:
 
 
 def test_serialized_program_to() -> None:
-    prg = "(q ((0x0101010101010101010101010101010101010101010101010101010101010101 80 123 (() (q . ())))))"  # noqa
-    tests: List[CastableType] = [
+    prg = "(q ((0x0101010101010101010101010101010101010101010101010101010101010101 80 123 (() (q . ())))))"
+    tests: list[CastableType] = [
         0,
         1,
         (1, 2),