chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/_tests/environments/wallet.py

@@ -25,6 +25,7 @@ from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import Balance, WalletNode
 from chia.wallet.wallet_node_api import WalletNodeAPI
+from chia.wallet.wallet_request_types import GetWalletBalance
 from chia.wallet.wallet_rpc_api import WalletRpcApi
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_state_manager import WalletStateManager
@@ -169,7 +170,9 @@ class WalletEnvironment:
                     else {}
                 ),
             }
-            balance_response: dict[str, int] = await self.rpc_client.get_wallet_balance(wallet_id)
+            balance_response: dict[str, int] = (
+                await self.rpc_client.get_wallet_balance(GetWalletBalance(wallet_id))
+            ).wallet_balance.to_json_dict()
 
             if not expected_result.items() <= balance_response.items():
                 for key, value in expected_result.items():

chia/_tests/farmer_harvester/test_farmer.py

@@ -9,7 +9,7 @@ from typing import Any, Optional, Union, cast
 from unittest.mock import ANY
 
 import pytest
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey, ProofOfSpace
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PlotSize, PrivateKey, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 from pytest_mock import MockerFixture
@@ -21,15 +21,17 @@ from chia._tests.conftest import HarvesterFarmerEnvironment
 from chia._tests.util.misc import DataCase, Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.farmer.farmer import UPDATE_POOL_FARMER_INFO_INTERVAL, Farmer, increment_pool_stats, strip_old_entries
+from chia.farmer.farmer_service import FarmerService
+from chia.harvester.harvester_service import HarvesterService
 from chia.pools.pool_config import PoolWalletConfig
 from chia.protocols import farmer_protocol, harvester_protocol
 from chia.protocols.harvester_protocol import NewProofOfSpace, RespondSignatures
 from chia.protocols.pool_protocol import PoolErrorCode
-from chia.server.aliases import FarmerService, HarvesterService
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
 from chia.types.blockchain_format.proof_of_space import (
     generate_plot_public_key,
+    make_pos,
     verify_and_get_quality_string,
 )
 from chia.util.config import load_config, save_config
@@ -132,7 +134,7 @@ class NewProofOfSpaceCase:
     plot_identifier: str
     signage_point_index: uint8
     plot_id: bytes32
-    plot_size: uint8
+    plot_size: PlotSize
     plot_challenge: bytes32
     plot_public_key: G1Element
     pool_public_key: Optional[G1Element]
@@ -187,7 +189,7 @@ class NewProofOfSpaceCase:
             plot_identifier="test",
             signage_point_index=uint8(1),
             plot_id=bytes32.fromhex("baaa6780c53d4b3739b8807b4ae79a76644ddf0d9e03dc7d0a6a0e613e764d9f"),
-            plot_size=uint8(32),
+            plot_size=PlotSize.make_v1(32),
             plot_challenge=bytes32.fromhex("7580e4c366dc2c94c37ce44943f9629a3cd6e027d7b24cd014adeaa578d4b0a2"),
             plot_public_key=G1Element.from_bytes(
                 bytes.fromhex(
@@ -573,7 +575,7 @@ async def test_farmer_new_proof_of_space_for_pool_stats(
         peak_height=uint32(1),
         last_tx_height=uint32(0),
     )
-    pos = ProofOfSpace(
+    pos = make_pos(
         challenge=case.plot_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,
@@ -714,7 +716,7 @@ def create_valid_pos(farmer: Farmer) -> tuple[farmer_protocol.NewSignagePoint, P
         peak_height=uint32(1),
         last_tx_height=uint32(0),
     )
-    pos = ProofOfSpace(
+    pos = make_pos(
         challenge=case.plot_challenge,
         pool_public_key=case.pool_public_key,
         pool_contract_puzzle_hash=case.pool_contract_puzzle_hash,

chia/_tests/farmer_harvester/test_farmer_harvester.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import asyncio
+import unittest.mock
 from math import floor
 from pathlib import Path
 from typing import Any, Optional
+from unittest.mock import AsyncMock, Mock
 
 import pytest
 from chia_rs import G1Element
@@ -15,19 +17,41 @@ from chia._tests.util.split_managers import split_async_manager
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.cmds.cmds_util import get_any_service_client
 from chia.farmer.farmer import Farmer
+from chia.farmer.farmer_service import FarmerService
 from chia.harvester.harvester_rpc_client import HarvesterRpcClient
+from chia.harvester.harvester_service import HarvesterService
 from chia.plotting.util import PlotsRefreshParameter
-from chia.protocols import farmer_protocol, harvester_protocol
+from chia.protocols import farmer_protocol, harvester_protocol, solver_protocol
 from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.aliases import FarmerService, HarvesterService
 from chia.simulator.block_tools import BlockTools
+from chia.solver.solver_service import SolverService
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.config import load_config
 from chia.util.hash import std_hash
 from chia.util.keychain import generate_mnemonic
 
 
+async def get_harvester_peer(farmer: Farmer) -> Any:
+    """wait for harvester connection and return the peer"""
+
+    def has_harvester_connection() -> bool:
+        return len(farmer.server.get_connections(NodeType.HARVESTER)) > 0
+
+    await time_out_assert(10, has_harvester_connection, True)
+    return farmer.server.get_connections(NodeType.HARVESTER)[0]
+
+
+async def get_solver_peer(farmer: Farmer) -> Any:
+    """wait for solver connection and return the peer"""
+
+    def has_solver_connection() -> bool:
+        return len(farmer.server.get_connections(NodeType.SOLVER)) > 0
+
+    await time_out_assert(60, has_solver_connection, True)
+    return farmer.server.get_connections(NodeType.SOLVER)[0]
+
+
 def farmer_is_started(farmer: Farmer) -> bool:
     return farmer.started
 
@@ -143,9 +167,6 @@ async def test_farmer_respond_signatures(
     # messages even though it didn't request them, to cover when the farmer doesn't know
     # about an sp_hash, so it fails at the sp record check.
 
-    def log_is_ready() -> bool:
-        return len(caplog.text) > 0
-
     _, _, harvester_service, _, _ = harvester_farmer_environment
     # We won't have an sp record for this one
     challenge_hash = bytes32(b"1" * 32)
@@ -160,11 +181,16 @@ async def test_farmer_respond_signatures(
         include_source_signature_data=False,
         farmer_reward_address_override=None,
     )
+
+    expected_error = f"Do not have challenge hash {challenge_hash}"
+
+    def expected_log_is_ready() -> bool:
+        return expected_error in caplog.text
+
     msg = make_msg(ProtocolMessageTypes.respond_signatures, response)
     await harvester_service._node.server.send_to_all([msg], NodeType.FARMER)
-    await time_out_assert(5, log_is_ready)
-    # We fail the sps record check
-    expected_error = f"Do not have challenge hash {challenge_hash}"
+    await time_out_assert(10, expected_log_is_ready)
+    # We should find the error message
     assert expected_error in caplog.text
 
 
@@ -297,3 +323,275 @@ async def test_harvester_has_no_server(
     harvester_server = harvesters[0]._server
 
     assert harvester_server.webserver is None
+
+
+@pytest.mark.anyio
+async def test_v2_partial_proofs_new_sp_hash(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _solver_service, _bt = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    sp_hash = bytes32(b"1" * 32)
+    partial_proofs = harvester_protocol.PartialProofsData(
+        challenge_hash=bytes32(b"2" * 32),
+        sp_hash=sp_hash,
+        plot_identifier="test_plot_id",
+        partial_proofs=[b"test_partial_proof_1"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=None,
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = await get_harvester_peer(farmer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
+
+    assert sp_hash in farmer.number_of_responses
+    assert farmer.number_of_responses[sp_hash] == 0
+    assert sp_hash in farmer.cache_add_time
+
+
+@pytest.mark.anyio
+async def test_v2_partial_proofs_missing_sp_hash(
+    caplog: pytest.LogCaptureFixture,
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+
+    sp_hash = bytes32(b"1" * 32)
+    partial_proofs = harvester_protocol.PartialProofsData(
+        challenge_hash=bytes32(b"2" * 32),
+        sp_hash=sp_hash,
+        plot_identifier="test_plot_id",
+        partial_proofs=[b"test_partial_proof_1"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=None,
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = await get_harvester_peer(farmer_api.farmer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
+
+    assert f"Received partial proofs for a signage point that we do not have {sp_hash}" in caplog.text
+
+
+@pytest.mark.anyio
+async def test_v2_partial_proofs_with_existing_sp(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    sp_hash = bytes32(b"1" * 32)
+    challenge_hash = bytes32(b"2" * 32)
+
+    sp = farmer_protocol.NewSignagePoint(
+        challenge_hash=challenge_hash,
+        challenge_chain_sp=sp_hash,
+        reward_chain_sp=std_hash(b"1"),
+        difficulty=uint64(1000),
+        sub_slot_iters=uint64(1000),
+        signage_point_index=uint8(0),
+        peak_height=uint32(1),
+        last_tx_height=uint32(0),
+    )
+
+    farmer.sps[sp_hash] = [sp]
+
+    partial_proofs = harvester_protocol.PartialProofsData(
+        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"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=G1Element(),
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = await get_harvester_peer(farmer)
+    await farmer_api.partial_proofs(partial_proofs, harvester_peer)
+
+    # should store 2 pending requests (one per partial proof)
+    assert len(farmer.pending_solver_requests) == 2
+    assert sp_hash in farmer.cache_add_time
+
+
+@pytest.mark.anyio
+async def test_solution_response_handler(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    # set up a pending request
+    sp_hash = bytes32(b"1" * 32)
+    challenge_hash = bytes32(b"2" * 32)
+
+    partial_proofs = harvester_protocol.PartialProofsData(
+        challenge_hash=challenge_hash,
+        sp_hash=sp_hash,
+        plot_identifier="test_plot_id",
+        partial_proofs=[b"test_partial_proof_for_quality"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=G1Element(),
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = await get_harvester_peer(farmer)
+
+    # manually add pending request
+    farmer.pending_solver_requests[partial_proofs.partial_proofs[0]] = {
+        "proof_data": partial_proofs,
+        "peer": harvester_peer,
+    }
+
+    # create solution response
+    solution_response = solver_protocol.SolverResponse(
+        partial_proof=partial_proofs.partial_proofs[0], proof=b"test_proof_from_solver"
+    )
+    solver_peer = Mock()
+    solver_peer.peer_node_id = "solver_peer"
+
+    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)
+
+        # verify new_proof_of_space was called with correct proof
+        mock_new_proof.assert_called_once()
+        call_args = mock_new_proof.call_args[0]
+        new_proof_of_space = call_args[0]
+        original_peer = call_args[1]
+
+        assert new_proof_of_space.proof.proof == b"test_proof_from_solver"
+        assert original_peer == harvester_peer
+
+        # verify pending request was removed
+        assert partial_proofs.partial_proofs[0] not in farmer.pending_solver_requests
+
+
+@pytest.mark.anyio
+async def test_solution_response_unknown_quality(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    # get real solver peer connection
+    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")
+
+    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)
+        # verify new_proof_of_space was NOT called
+        mock_new_proof.assert_not_called()
+        # verify pending requests unchanged
+        assert len(farmer.pending_solver_requests) == 0
+
+
+@pytest.mark.anyio
+async def test_solution_response_empty_proof(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _solver_service, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    # set up a pending request
+    sp_hash = bytes32(b"1" * 32)
+    challenge_hash = bytes32(b"2" * 32)
+
+    partial_proofs = harvester_protocol.PartialProofsData(
+        challenge_hash=challenge_hash,
+        sp_hash=sp_hash,
+        plot_identifier="test_plot_id",
+        partial_proofs=[b"test_partial_proof_for_quality"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=G1Element(),
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = Mock()
+    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],
+        "peer": harvester_peer,
+    }
+
+    # get real solver peer connection
+    solver_peer = await get_solver_peer(farmer)
+
+    # create solution response with empty proof
+    solution_response = solver_protocol.SolverResponse(partial_proof=partial_proofs.partial_proofs[0], proof=b"")
+
+    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)
+
+        # verify new_proof_of_space was NOT called
+        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
+
+
+@pytest.mark.anyio
+async def test_v2_partial_proofs_solver_exception(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, _solver_service, _ = farmer_one_harvester_solver
+    farmer_api = farmer_service._api
+    farmer = farmer_api.farmer
+
+    sp_hash = bytes32(b"1" * 32)
+    challenge_hash = bytes32(b"2" * 32)
+
+    sp = farmer_protocol.NewSignagePoint(
+        challenge_hash=challenge_hash,
+        challenge_chain_sp=sp_hash,
+        reward_chain_sp=std_hash(b"1"),
+        difficulty=uint64(1000),
+        sub_slot_iters=uint64(1000),
+        signage_point_index=uint8(0),
+        peak_height=uint32(1),
+        last_tx_height=uint32(0),
+    )
+
+    farmer.sps[sp_hash] = [sp]
+
+    partial_proofs = harvester_protocol.PartialProofsData(
+        challenge_hash=challenge_hash,
+        sp_hash=sp_hash,
+        plot_identifier="test_plot_id",
+        partial_proofs=[b"test_partial_proof_1"],
+        signage_point_index=uint8(0),
+        plot_size=uint8(32),
+        pool_public_key=G1Element(),
+        pool_contract_puzzle_hash=bytes32(b"4" * 32),
+        plot_public_key=G1Element(),
+    )
+
+    harvester_peer = await get_harvester_peer(farmer)
+
+    # Mock send_to_all to raise an exception
+    with unittest.mock.patch.object(farmer.server, "send_to_all", side_effect=Exception("Solver connection failed")):
+        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

chia/_tests/farmer_harvester/test_filter_prefix_bits.py

@@ -11,13 +11,13 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia._tests.conftest import ConsensusMode
 from chia._tests.core.test_farmer_harvester_rpc import wait_for_plot_sync
-from chia._tests.util.setup_nodes import setup_farmer_multi_harvester
+from chia._tests.util.setup_nodes import setup_farmer_solver_multi_harvester
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.farmer.farmer_api import FarmerAPI
 from chia.farmer.farmer_rpc_client import FarmerRpcClient
 from chia.harvester.harvester_rpc_client import HarvesterRpcClient
+from chia.harvester.harvester_service import HarvesterService
 from chia.protocols import farmer_protocol
-from chia.server.aliases import HarvesterService
 from chia.simulator.block_tools import create_block_tools_async, test_constants
 from chia.types.blockchain_format.proof_of_space import get_plot_id, passes_plot_filter
 from chia.util.keychain import Keychain
@@ -60,7 +60,7 @@ async def farmer_harvester_with_filter_size_9(
     )
     new_config = local_b_tools._config
     local_b_tools.change_config(new_config)
-    async with setup_farmer_multi_harvester(
+    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]

chia/_tests/farmer_harvester/test_third_party_harvesters.py

@@ -31,15 +31,17 @@ from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_dif
 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.farmer.farmer_service import FarmerService
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
+from chia.full_node.full_node_service import FullNodeService
 from chia.harvester.harvester import Harvester
 from chia.harvester.harvester_api import HarvesterAPI
+from chia.harvester.harvester_service import HarvesterService
 from chia.protocols import farmer_protocol, full_node_protocol, harvester_protocol, timelord_protocol
 from chia.protocols.harvester_protocol import ProofOfSpaceFeeInfo, RespondSignatures, SigningDataKind
 from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.server.aliases import FarmerService, FullNodeService, HarvesterService
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.block_tools import BlockTools
@@ -82,17 +84,16 @@ async def test_harvester_receive_source_signing_data(
     full_node_1: FullNode = full_node_service_1._node
     full_node_2: FullNode = full_node_service_2._node
 
+    await time_out_assert(60, node_type_connected, True, farmer.server, NodeType.HARVESTER)
     # Connect peers to each other
     farmer_service.add_peer(
         UnresolvedPeerInfo(str(full_node_service_2.self_hostname), full_node_service_2._server.get_port())
     )
+    await time_out_assert(60, node_type_connected, True, farmer.server, NodeType.FULL_NODE)
     full_node_service_2.add_peer(
         UnresolvedPeerInfo(str(full_node_service_1.self_hostname), full_node_service_1._server.get_port())
     )
-
-    await wait_until_node_type_connected(farmer.server, NodeType.FULL_NODE)
-    await wait_until_node_type_connected(farmer.server, NodeType.HARVESTER)  # Should already be connected
-    await wait_until_node_type_connected(full_node_1.server, NodeType.FULL_NODE)
+    await time_out_assert(60, node_type_connected, True, full_node_1.server, NodeType.FULL_NODE)
 
     # Prepare test data
     blocks: list[FullBlock]
@@ -427,12 +428,11 @@ async def scan_log_for_message(caplog: pytest.LogCaptureFixture, find_message: s
     return False
 
 
-async def wait_until_node_type_connected(server: ChiaServer, node_type: NodeType) -> WSChiaConnection:
-    while True:
-        for peer in server.all_connections.values():
-            if peer.connection_type == node_type.value:
-                return peer
-        await asyncio.sleep(1)
+def node_type_connected(server: ChiaServer, node_type: NodeType) -> bool:
+    for peer in server.all_connections.values():
+        if peer.connection_type == node_type.value:
+            return True
+    return False
 
 
 def decode_sp(

chia/_tests/fee_estimation/test_fee_estimation_integration.py

@@ -40,9 +40,9 @@ def make_mempoolitem() -> MempoolItem:
 
     fee = uint64(10000000)
     spends: list[SpendConditions] = []
-    conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0)
+    conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0, 0, 0, 0)
     mempool_item = MempoolItem(
-        spend_bundle,
+        spend_bundle.aggregated_signature,
         fee,
         conds,
         spend_bundle.name(),

chia/_tests/fee_estimation/test_fee_estimation_rpc.py

@@ -10,7 +10,6 @@ from chia_rs.sized_ints import uint64
 
 from chia.full_node.full_node_rpc_api import FullNodeRpcApi
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
-from chia.server.aliases import WalletService
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
@@ -18,6 +17,7 @@ from chia.simulator.start_simulator import SimulatorFullNodeService
 from chia.simulator.wallet_tools import WalletTool
 from chia.types.blockchain_format.coin import Coin
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+from chia.wallet.wallet_service import WalletService
 
 
 @pytest.fixture(scope="function")

chia/_tests/fee_estimation/test_fee_estimation_unit_tests.py

@@ -68,8 +68,7 @@ def test_steady_fee_pressure() -> None:
     estimates_during = []
     start_from = 250
     for height in range(start, end):
-        height = uint32(height)
-        items = make_block(height, 1, cost, fee, num_blocks_wait_in_mempool)
+        items = make_block(uint32(height), 1, cost, fee, num_blocks_wait_in_mempool)
         estimator.new_block(FeeBlockInfo(uint32(height), items))
         if height >= start_from:
             estimation = estimator.estimate_fee_rate(time_offset_seconds=time_offset_seconds * (height - start_from))

chia/_tests/generator/test_rom.py

@@ -146,7 +146,7 @@ class TestROM:
             before_seconds_relative=None,
             birth_height=None,
             birth_seconds=None,
-            create_coin=[(bytes([0] * 31 + [1]), 500, None)],
+            create_coin=[(bytes32([0] * 31 + [1]), 500, None)],
             agg_sig_me=[],
             agg_sig_parent=[],
             agg_sig_puzzle=[],
@@ -159,6 +159,7 @@ class TestROM:
             # execution cost, just in run_block_generator2()
             execution_cost=0 if softfork_height < DEFAULT_CONSTANTS.HARD_FORK_HEIGHT else 44,
             condition_cost=1800000,
+            fingerprint=b"",
         )
 
         assert npc_result.conds.spends == [spend]

chia/_tests/harvester/config.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+job_timeout = 70
+checkout_blocks_and_plots = True