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

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 from math import floor
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 from chia_rs import G1Element
@@ -32,19 +32,19 @@ 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 with get_any_service_client(HarvesterRpcClient, harvester_rpc_port, root_path) as (harvester_client, _):
+async def get_harvester_config(harvester_rpc_port: Optional[int], 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 with get_any_service_client(HarvesterRpcClient, harvester_rpc_port, root_path) as (harvester_client, _):
+async def update_harvester_config(harvester_rpc_port: Optional[int], 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)
 
 
 @pytest.mark.anyio
 async def test_start_with_empty_keychain(
-    farmer_one_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools]
+    farmer_one_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
 ) -> None:
     _, farmer_service, bt = farmer_one_harvester_not_started
     farmer: Farmer = farmer_service._node
@@ -67,7 +67,7 @@ async def test_start_with_empty_keychain(
 
 @pytest.mark.anyio
 async def test_harvester_handshake(
-    farmer_one_harvester_not_started: Tuple[List[HarvesterService], FarmerService, BlockTools]
+    farmer_one_harvester_not_started: tuple[list[HarvesterService], FarmerService, BlockTools],
 ) -> None:
     harvesters, farmer_service, bt = farmer_one_harvester_not_started
     harvester_service = harvesters[0]
@@ -169,8 +169,8 @@ async def test_farmer_respond_signatures(
 
 
 @pytest.mark.anyio
-async def test_harvester_config(farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools]) -> None:
-    harvester_services, farmer_service, bt = farmer_one_harvester
+async def test_harvester_config(farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools]) -> None:
+    harvester_services, _farmer_service, bt = farmer_one_harvester
     harvester_service = harvester_services[0]
 
     assert harvester_service.rpc_server and harvester_service.rpc_server.webserver
@@ -179,7 +179,7 @@ async def test_harvester_config(farmer_one_harvester: Tuple[List[HarvesterServic
     harvester_config = await get_harvester_config(harvester_rpc_port, bt.root_path)
     assert harvester_config["success"] is True
 
-    def check_config_match(config1: Dict[str, Any], config2: Dict[str, Any]) -> None:
+    def check_config_match(config1: dict[str, Any], config2: dict[str, Any]) -> None:
         assert config1["harvester"]["use_gpu_harvesting"] == config2["use_gpu_harvesting"]
         assert config1["harvester"]["gpu_index"] == config2["gpu_index"]
         assert config1["harvester"]["enforce_gpu_index"] == config2["enforce_gpu_index"]
@@ -202,7 +202,7 @@ async def test_harvester_config(farmer_one_harvester: Tuple[List[HarvesterServic
     harvester_config["parallel_decompressor_count"] += 1
     harvester_config["decompressor_thread_count"] += 1
     harvester_config["recursive_plot_scan"] = not harvester_config["recursive_plot_scan"]
-    harvester_config["refresh_parameter_interval_seconds"] = harvester_config["refresh_parameter_interval_seconds"] + 1
+    harvester_config["refresh_parameter_interval_seconds"] += 1
 
     res = await update_harvester_config(harvester_rpc_port, bt.root_path, harvester_config)
     assert res is True
@@ -212,13 +212,13 @@ async def test_harvester_config(farmer_one_harvester: Tuple[List[HarvesterServic
 
 @pytest.mark.anyio
 async def test_missing_signage_point(
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools]
+    farmer_one_harvester: tuple[list[HarvesterService], FarmerService, BlockTools],
 ) -> None:
-    _, farmer_service, bt = farmer_one_harvester
+    _, farmer_service, _bt = farmer_one_harvester
     farmer_api = farmer_service._api
     farmer = farmer_api.farmer
 
-    def create_sp(index: int, challenge_hash: bytes32) -> Tuple[uint64, farmer_protocol.NewSignagePoint]:
+    def create_sp(index: int, challenge_hash: bytes32) -> tuple[uint64, farmer_protocol.NewSignagePoint]:
         time = uint64(index + 1)
         sp = farmer_protocol.NewSignagePoint(
             challenge_hash, std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(index), uint32(1)
@@ -271,7 +271,7 @@ async def test_missing_signage_point(
     assert original_state_changed_callback is not None
     number_of_missing_sps: uint32 = uint32(0)
 
-    def state_changed(change: str, data: Dict[str, Any]) -> None:
+    def state_changed(change: str, data: dict[str, Any]) -> None:
         nonlocal number_of_missing_sps
         number_of_missing_sps = data["missing_signage_points"][1]
         original_state_changed_callback(change, data)
@@ -284,9 +284,9 @@ async def test_missing_signage_point(
 
 @pytest.mark.anyio
 async def test_harvester_has_no_server(
-    farmer_one_harvester: Tuple[List[FarmerService], HarvesterService, BlockTools],
+    farmer_one_harvester: tuple[list[FarmerService], HarvesterService, BlockTools],
 ) -> None:
-    harvesters, _, bt = farmer_one_harvester
+    harvesters, _, _bt = farmer_one_harvester
     harvester_server = harvesters[0]._server
 
     assert harvester_server.webserver is None

chia/_tests/farmer_harvester/test_filter_prefix_bits.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 import pytest
 
@@ -31,7 +32,7 @@ from chia.util.keychain import Keychain
     argnames=["filter_prefix_bits", "should_pass"], argvalues=[(9, 34), (8, 89), (7, 162), (6, 295), (5, 579)]
 )
 def test_filter_prefix_bits_on_blocks(
-    default_10000_blocks: List[FullBlock], filter_prefix_bits: uint8, should_pass: int
+    default_10000_blocks: list[FullBlock], filter_prefix_bits: uint8, should_pass: int
 ) -> None:
     passed = 0
     for block in default_10000_blocks:
@@ -50,7 +51,7 @@ def test_filter_prefix_bits_on_blocks(
 @pytest.fixture(scope="function")
 async def farmer_harvester_with_filter_size_9(
     get_temp_keyring: Keychain, tmp_path: Path, self_hostname: str
-) -> AsyncIterator[Tuple[HarvesterService, FarmerAPI]]:
+) -> AsyncIterator[tuple[HarvesterService, FarmerAPI]]:
     async def have_connections() -> bool:
         return len(await farmer_rpc_cl.get_connections()) > 0
 
@@ -86,14 +87,14 @@ async def farmer_harvester_with_filter_size_9(
 @pytest.mark.parametrize(argnames=["peak_height", "eligible_plots"], argvalues=[(5495999, 0), (5496000, 1)])
 @pytest.mark.anyio
 async def test_filter_prefix_bits_with_farmer_harvester(
-    farmer_harvester_with_filter_size_9: Tuple[HarvesterService, FarmerAPI],
+    farmer_harvester_with_filter_size_9: tuple[HarvesterService, FarmerAPI],
     peak_height: uint32,
     eligible_plots: int,
 ) -> None:
     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: Optional[dict[str, Any]]) -> None:
         nonlocal state_change, state_change_data
         state_change = change
         state_change_data = change_data

chia/_tests/farmer_harvester/test_third_party_harvesters.py

@@ -2,20 +2,22 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import contextlib
 import dataclasses
 import json
 import logging
 from os.path import dirname
-from typing import Any, List, Optional, Tuple, Union, cast
+from typing import Optional, Union, cast
 
 import pytest
 from chia_rs import G1Element
-from pytest_mock import MockerFixture
 
+from chia._tests.util.misc import patch_request_handler
 from chia._tests.util.time_out_assert import time_out_assert
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import AddBlockResult
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
-from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_blocks_multiprocessing
+from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.farmer.farmer import Farmer, calculate_harvester_fee_quality
 from chia.farmer.farmer_api import FarmerAPI
 from chia.full_node.full_node import FullNode
@@ -23,7 +25,6 @@ from chia.full_node.full_node_api import FullNodeAPI
 from chia.harvester.harvester import Harvester
 from chia.harvester.harvester_api import HarvesterAPI
 from chia.protocols import farmer_protocol, full_node_protocol, harvester_protocol, timelord_protocol
-from chia.protocols.farmer_protocol import RequestSignedValues
 from chia.protocols.harvester_protocol import ProofOfSpaceFeeInfo, RespondSignatures, SigningDataKind
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.outbound_message import Message, NodeType, make_msg
@@ -39,24 +40,25 @@ from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
 from chia.types.full_block import FullBlock
 from chia.types.peer_info import UnresolvedPeerInfo
+from chia.types.validation_state import ValidationState
+from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.bech32m import decode_puzzle_hash
 from chia.util.hash import std_hash
 from chia.util.ints import uint8, uint32, uint64
 
 SPType = Union[timelord_protocol.NewEndOfSubSlotVDF, timelord_protocol.NewSignagePointVDF]
-SPList = List[SPType]
+SPList = list[SPType]
 
 
 @pytest.mark.anyio
 async def test_harvester_receive_source_signing_data(
-    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+    farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
         Union[FullNodeService, SimulatorFullNodeService],
         Union[FullNodeService, SimulatorFullNodeService],
         BlockTools,
     ],
-    mocker: MockerFixture,
 ) -> None:
     """
     Tests that the source data for the signatures requests sent to the
@@ -90,7 +92,7 @@ async def test_harvester_receive_source_signing_data(
     await wait_until_node_type_connected(full_node_1.server, NodeType.FULL_NODE)
 
     # Prepare test data
-    blocks: List[FullBlock]
+    blocks: list[FullBlock]
     signage_points: SPList
 
     (blocks, signage_points) = load_test_data()
@@ -112,8 +114,9 @@ async def test_harvester_receive_source_signing_data(
     finished_validating_data = False
     farmer_reward_address = decode_puzzle_hash("txch1psqeaw0h244v5sy2r4se8pheyl62n8778zl6t5e7dep0xch9xfkqhx2mej")
 
-    async def intercept_harvester_request_signatures(*args: Any) -> Message:
-        request: harvester_protocol.RequestSignatures = harvester_protocol.RequestSignatures.from_bytes(args[0])
+    async def intercept_harvester_request_signatures(
+        self: HarvesterAPI, request: harvester_protocol.RequestSignatures
+    ) -> Optional[Message]:
         nonlocal harvester
         nonlocal farmer_reward_address
 
@@ -207,24 +210,23 @@ async def test_harvester_receive_source_signing_data(
             data_hash = data.get_hash()
             assert data_hash == hash
 
-    async def intercept_farmer_new_proof_of_space(*args: Any) -> None:
+    async def intercept_farmer_new_proof_of_space(
+        self: HarvesterAPI, request: harvester_protocol.NewProofOfSpace, peer: WSChiaConnection
+    ) -> None:
         nonlocal farmer
         nonlocal farmer_reward_address
 
-        request: harvester_protocol.NewProofOfSpace = dataclasses.replace(
-            harvester_protocol.NewProofOfSpace.from_bytes(args[0]), farmer_reward_address_override=farmer_reward_address
-        )
-        peer: WSChiaConnection = args[1]
+        request = dataclasses.replace(request, farmer_reward_address_override=farmer_reward_address)
 
         await FarmerAPI.new_proof_of_space(farmer.server.api, request, peer)
 
-    async def intercept_farmer_request_signed_values(*args: Any) -> Optional[Message]:
+    async def intercept_farmer_request_signed_values(
+        self: FarmerAPI, request: farmer_protocol.RequestSignedValues
+    ) -> Optional[Message]:
         nonlocal farmer
         nonlocal farmer_reward_address
         nonlocal full_node_2
 
-        request: RequestSignedValues = RequestSignedValues.from_bytes(args[0])
-
         # Ensure the FullNode included the source data for the signatures
         assert request.foliage_block_data
         assert request.foliage_block_data.get_hash() == request.foliage_block_data_hash
@@ -239,23 +241,42 @@ async def test_harvester_receive_source_signing_data(
 
         return await FarmerAPI.request_signed_values(farmer.server.api, request)
 
-    mocker.patch.object(farmer.server.api, "request_signed_values", side_effect=intercept_farmer_request_signed_values)
-    mocker.patch.object(farmer.server.api, "new_proof_of_space", side_effect=intercept_farmer_new_proof_of_space)
-    mocker.patch.object(harvester.server.api, "request_signatures", side_effect=intercept_harvester_request_signatures)
+    with contextlib.ExitStack() as exit_stack:
+        exit_stack.enter_context(
+            patch_request_handler(
+                api=farmer.server.api,
+                handler=intercept_farmer_request_signed_values,
+                request_type=ProtocolMessageTypes.request_signed_values,
+            )
+        )
+        exit_stack.enter_context(
+            patch_request_handler(
+                api=farmer.server.api,
+                handler=intercept_farmer_new_proof_of_space,
+                request_type=ProtocolMessageTypes.new_proof_of_space,
+            )
+        )
+        exit_stack.enter_context(
+            patch_request_handler(
+                api=harvester.server.api,
+                handler=intercept_harvester_request_signatures,
+                request_type=ProtocolMessageTypes.request_signatures,
+            )
+        )
 
-    # Start injecting signage points
-    await inject_signage_points(signage_points, full_node_1, full_node_2)
+        # Start injecting signage points
+        await inject_signage_points(signage_points, full_node_1, full_node_2)
 
-    # Wait until test finishes
-    def did_finished_validating_data() -> bool:
-        return finished_validating_data
+        # Wait until test finishes
+        def did_finished_validating_data() -> bool:
+            return finished_validating_data
 
-    await time_out_assert(60 * 60, did_finished_validating_data, True)
+        await time_out_assert(60, did_finished_validating_data, True)
 
 
 @pytest.mark.anyio
 async def test_harvester_fee_convention(
-    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+    farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
         Union[FullNodeService, SimulatorFullNodeService],
@@ -285,7 +306,7 @@ async def test_harvester_fee_convention(
 
 @pytest.mark.anyio
 async def test_harvester_fee_invalid_convention(
-    farmer_harvester_2_simulators_zero_bits_plot_filter: Tuple[
+    farmer_harvester_2_simulators_zero_bits_plot_filter: tuple[
         FarmerService,
         HarvesterService,
         Union[FullNodeService, SimulatorFullNodeService],
@@ -318,7 +339,7 @@ async def test_harvester_fee_invalid_convention(
 
 def prepare_sp_and_pos_for_fee_test(
     fee_threshold_offset: int,
-) -> Tuple[farmer_protocol.NewSignagePoint, harvester_protocol.NewProofOfSpace]:
+) -> tuple[farmer_protocol.NewSignagePoint, harvester_protocol.NewProofOfSpace]:
     proof = std_hash(b"1")
     challenge = std_hash(b"1")
 
@@ -419,7 +440,7 @@ def decode_sp(
     return timelord_protocol.NewSignagePointVDF.from_bytes(sp_bytes)
 
 
-async def add_test_blocks_into_full_node(blocks: List[FullBlock], full_node: FullNode) -> None:
+async def add_test_blocks_into_full_node(blocks: list[FullBlock], full_node: FullNode) -> None:
     # Inject full node with a pre-existing block to skip initial genesis sub-slot
     # so that we have blocks generated that have our farmer reward address, instead
     # of the GENESIS_PRE_FARM_FARMER_PUZZLE_HASH.
@@ -435,31 +456,37 @@ async def add_test_blocks_into_full_node(blocks: List[FullBlock], full_node: Ful
         prev_ses_block = curr
     new_slot = len(block.finished_sub_slots) > 0
     ssi, diff = get_next_sub_slot_iters_and_difficulty(full_node.constants, new_slot, prev_b, full_node.blockchain)
-    pre_validation_results: List[PreValidationResult] = await pre_validate_blocks_multiprocessing(
-        full_node.blockchain.constants,
-        full_node.blockchain,
-        blocks,
-        full_node.blockchain.pool,
-        {},
-        sub_slot_iters=ssi,
-        difficulty=diff,
-        prev_ses_block=prev_ses_block,
-        validate_signatures=True,
-    )
+    futures = []
+    chain = AugmentedBlockchain(full_node.blockchain)
+    for block in blocks:
+        futures.append(
+            await pre_validate_block(
+                full_node.blockchain.constants,
+                chain,
+                block,
+                full_node.blockchain.pool,
+                None,
+                ValidationState(ssi, diff, prev_ses_block),
+            )
+        )
+    pre_validation_results: list[PreValidationResult] = list(await asyncio.gather(*futures))
     assert pre_validation_results is not None and len(pre_validation_results) == len(blocks)
     for i in range(len(blocks)):
         block = blocks[i]
         if block.height != 0 and len(block.finished_sub_slots) > 0:  # pragma: no cover
             if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
                 ssi = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
-        r, _, _ = await full_node.blockchain.add_block(blocks[i], pre_validation_results[i], None, sub_slot_iters=ssi)
+        fork_info = ForkInfo(block.height - 1, block.height - 1, block.prev_header_hash)
+        r, _, _ = await full_node.blockchain.add_block(
+            blocks[i], pre_validation_results[i], sub_slot_iters=ssi, fork_info=fork_info
+        )
         assert r == AddBlockResult.NEW_PEAK
 
 
 async def inject_signage_points(signage_points: SPList, full_node_1: FullNode, full_node_2: FullNode) -> None:
-    full_node_2_peer_1 = [
+    full_node_2_peer_1 = next(
         n for n in list(full_node_2.server.all_connections.values()) if n.local_type == NodeType.FULL_NODE
-    ][0]
+    )
 
     api2 = cast(FullNodeAPI, full_node_2.server.api)
 
@@ -491,7 +518,7 @@ async def inject_signage_points(signage_points: SPList, full_node_1: FullNode, f
 # A FullBlock is also included which is infused already in the chain so
 # that the next NewEndOfSubSlotVDF is valid.
 # This block has to be added to the test FullNode before injecting the signage points.
-def load_test_data() -> Tuple[List[FullBlock], SPList]:
+def load_test_data() -> tuple[list[FullBlock], SPList]:
     file_path: str = dirname(__file__) + "/test_third_party_harvesters_data.json"
     with open(file_path) as f:
         data = json.load(f)

chia/_tests/fee_estimation/test_fee_estimation_integration.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import types
-from typing import Dict, List
 
 import pytest
 from chia_rs import Coin
@@ -41,8 +40,8 @@ def make_mempoolitem() -> MempoolItem:
     block_height = 1
 
     fee = uint64(10000000)
-    spends: List[SpendConditions] = []
-    conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [], cost, 0, 0, False)
+    spends: list[SpendConditions] = []
+    conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0)
     mempool_item = MempoolItem(
         spend_bundle,
         fee,
@@ -125,7 +124,7 @@ def test_item_not_removed_if_not_added() -> None:
 
 
 def test_mempool_fee_estimator_remove_item() -> None:
-    should_call_fee_estimator_remove: Dict[MempoolRemoveReason, int] = {
+    should_call_fee_estimator_remove: dict[MempoolRemoveReason, int] = {
         MempoolRemoveReason.BLOCK_INCLUSION: 0,
         MempoolRemoveReason.CONFLICT: 1,
         MempoolRemoveReason.POOL_FULL: 1,
@@ -188,7 +187,7 @@ def test_current_block_height_new_block() -> None:
     fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
     mempool = Mempool(test_mempool_info, fee_estimator)
     height = uint32(10)
-    included_items: List[MempoolItemInfo] = []
+    included_items: list[MempoolItemInfo] = []
     mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
     assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
 
@@ -197,7 +196,7 @@ def test_current_block_height_new_height_then_new_block() -> None:
     fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
     mempool = Mempool(test_mempool_info, fee_estimator)
     height = uint32(11)
-    included_items: List[MempoolItemInfo] = []
+    included_items: list[MempoolItemInfo] = []
     fee_estimator.new_block_height(uint32(height - 1))
     mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
     assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
@@ -207,7 +206,7 @@ def test_current_block_height_new_block_then_new_height() -> None:
     fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
     mempool = Mempool(test_mempool_info, fee_estimator)
     height = uint32(12)
-    included_items: List[MempoolItemInfo] = []
+    included_items: list[MempoolItemInfo] = []
     fee_estimator.new_block_height(uint32(height - 1))
     mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
     fee_estimator.new_block_height(uint32(height + 1))
@@ -254,7 +253,8 @@ def test_add_tx_called() -> None:
 
     # Replace with test method
     mempool.fee_estimator.tracker.add_tx = types.MethodType(  # type: ignore[attr-defined]
-        add_tx_called_fun, mempool.fee_estimator.tracker  # type: ignore[attr-defined]
+        add_tx_called_fun,
+        mempool.fee_estimator.tracker,  # type: ignore[attr-defined]
     )
 
     mempool.add_to_pool(item)