checkpoint: into main from release/2.5.6 @ ecb54a5 (#20012)

Source hash: ecb54a5
Remaining commits: 1

In addition to changes in the network protocol and its generated files,
between the original and this checkpoint, here are the introduced code
changes in order to get back to a working state:

```diff
diff --git a/chia/_tests/harvester/test_harvester_api.py b/chia/_tests/harvester/test_harvester_api.py
index 479adb6..5c9e6d5 100644
--- a/chia/_tests/harvester/test_harvester_api.py
+++ b/chia/_tests/harvester/test_harvester_api.py
@@ -51,7 +51,7 @@ async def harvester_environment(
 
 def signage_point_from_block(
     block: FullBlock, constants: ConsensusConstants
-) -> harvester_protocol.NewSignagePointHarvester:
+) -> harvester_protocol.NewSignagePointHarvester2:
     sp_index = block.reward_chain_block.signage_point_index
     challenge_hash = block.reward_chain_block.pos_ss_cc_challenge_hash
     sp_hash = (
@@ -59,7 +59,7 @@ def signage_point_from_block(
         if block.reward_chain_block.reward_chain_sp_vdf
         else challenge_hash
     )
-    return harvester_protocol.NewSignagePointHarvester(
+    return harvester_protocol.NewSignagePointHarvester2(
         challenge_hash=challenge_hash,
         difficulty=uint64(constants.DIFFICULTY_STARTING),
         sub_slot_iters=uint64(constants.SUB_SLOT_ITERS_STARTING),
@@ -75,7 +75,7 @@ def create_test_setup(
     harvester_environment: HarvesterTestEnvironment,
     default_400_blocks: list[FullBlock],
     blockchain_constants: ConsensusConstants,
-) -> tuple[HarvesterTestEnvironment, harvester_protocol.NewSignagePointHarvester, MagicMock]:
+) -> tuple[HarvesterTestEnvironment, harvester_protocol.NewSignagePointHarvester2, MagicMock]:
     env = harvester_environment
     block = default_400_blocks[2]
     new_challenge = signage_point_from_block(block, blockchain_constants)
@@ -128,7 +128,7 @@ async def test_new_signage_point_harvester_pool_difficulty(
         sub_slot_iters=uint64(67108864),
     )
 
-    new_challenge = harvester_protocol.NewSignagePointHarvester(
+    new_challenge = harvester_protocol.NewSignagePointHarvester2(
         challenge_hash=new_challenge.challenge_hash,
         difficulty=new_challenge.difficulty,
         sub_slot_iters=new_challenge.sub_slot_iters,
diff --git a/chia/harvester/harvester_api.py b/chia/harvester/harvester_api.py
index 0ff578c74a..54fc6e1 100644
--- a/chia/harvester/harvester_api.py
+++ b/chia/harvester/harvester_api.py
@@ -53,7 +53,7 @@ class HarvesterAPI:
     def ready(self) -> bool:
         return True
 
-    def _plot_passes_filter(self, plot_info: PlotInfo, challenge: harvester_protocol.NewSignagePointHarvester) -> bool:
+    def _plot_passes_filter(self, plot_info: PlotInfo, challenge: harvester_protocol.NewSignagePointHarvester2) -> bool:
         filter_prefix_bits = calculate_prefix_bits(
             self.harvester.constants,
             challenge.peak_height,
```

Author: pmaslana

chia/_tests/harvester/test_harvester_api.py

@@ -51,15 +51,15 @@ async def harvester_environment(
 
 def signage_point_from_block(
     block: FullBlock, constants: ConsensusConstants
-) -> harvester_protocol.NewSignagePointHarvester:
+) -> harvester_protocol.NewSignagePointHarvester2:
     sp_index = block.reward_chain_block.signage_point_index
     challenge_hash = block.reward_chain_block.pos_ss_cc_challenge_hash
     sp_hash = (
         block.reward_chain_block.reward_chain_sp_vdf.output.get_hash()
         if block.reward_chain_block.reward_chain_sp_vdf
         else challenge_hash
     )
-    return harvester_protocol.NewSignagePointHarvester(
+    return harvester_protocol.NewSignagePointHarvester2(
         challenge_hash=challenge_hash,
         difficulty=uint64(constants.DIFFICULTY_STARTING),
         sub_slot_iters=uint64(constants.SUB_SLOT_ITERS_STARTING),
@@ -75,7 +75,7 @@ def create_test_setup(
     harvester_environment: HarvesterTestEnvironment,
     default_400_blocks: list[FullBlock],
     blockchain_constants: ConsensusConstants,
-) -> tuple[HarvesterTestEnvironment, harvester_protocol.NewSignagePointHarvester, MagicMock]:
+) -> tuple[HarvesterTestEnvironment, harvester_protocol.NewSignagePointHarvester2, MagicMock]:
     env = harvester_environment
     block = default_400_blocks[2]
     new_challenge = signage_point_from_block(block, blockchain_constants)
@@ -128,7 +128,7 @@ async def test_new_signage_point_harvester_pool_difficulty(
         sub_slot_iters=uint64(67108864),
     )
 
-    new_challenge = harvester_protocol.NewSignagePointHarvester(
+    new_challenge = harvester_protocol.NewSignagePointHarvester2(
         challenge_hash=new_challenge.challenge_hash,
         difficulty=new_challenge.difficulty,
         sub_slot_iters=new_challenge.sub_slot_iters,

chia/_tests/util/build_network_protocol_files.py

@@ -123,6 +123,7 @@ def visit_harvester_protocol(visitor: Callable[[Any, str], None]) -> None:
     visitor(pool_difficulty, "pool_difficulty")
     visitor(harvester_handhsake, "harvester_handhsake")
     visitor(new_signage_point_harvester, "new_signage_point_harvester")
+    visitor(new_signage_point_harvester2, "new_signage_point_harvester2")
     visitor(new_proof_of_space, "new_proof_of_space")
     visitor(request_signatures, "request_signatures")
     visitor(respond_signatures, "respond_signatures")

chia/_tests/util/network_protocol_data.py

@@ -810,6 +810,16 @@
 )
 
 new_signage_point_harvester = harvester_protocol.NewSignagePointHarvester(
+    bytes32(bytes.fromhex("e342c21b4aeaa52349d42492be934692db58494ca9bce4a8697d06fdf8e583bb")),
+    uint64(15615706268399948682),
+    uint64(10520767421667792980),
+    uint8(148),
+    bytes32(bytes.fromhex("b78c9fca155e9742df835cbe84bb7e518bee70d78b6be6e39996c0a02e0cfe4c")),
+    [pool_difficulty],
+    uint8(3),
+)
+
+new_signage_point_harvester2 = harvester_protocol.NewSignagePointHarvester2(
     bytes32(bytes.fromhex("e342c21b4aeaa52349d42492be934692db58494ca9bce4a8697d06fdf8e583bb")),
     uint64(15615706268399948682),
     uint64(10520767421667792980),
@@ -820,6 +830,7 @@
     uint32(0),
 )
 
+
 new_proof_of_space = harvester_protocol.NewProofOfSpace(
     bytes32.fromhex("1b64ec6bf3fe33bb80eca5b64ff1c88be07771eaed1e98a7199510522087e56e"),
     bytes32.fromhex("ad1f8a74376ce8c5c93b7fbb355c2fb6d689ae4f4a7134166593d95265a3da30"),

chia/_tests/util/protocol_messages_bytes-v1.0

@@ -2160,6 +2160,22 @@
 }
 
 new_signage_point_harvester_json: dict[str, Any] = {
+    "challenge_hash": "0xe342c21b4aeaa52349d42492be934692db58494ca9bce4a8697d06fdf8e583bb",
+    "difficulty": 15615706268399948682,
+    "sub_slot_iters": 10520767421667792980,
+    "signage_point_index": 148,
+    "sp_hash": "0xb78c9fca155e9742df835cbe84bb7e518bee70d78b6be6e39996c0a02e0cfe4c",
+    "pool_difficulties": [
+        {
+            "difficulty": 14819251421858580996,
+            "sub_slot_iters": 12852879676624401630,
+            "pool_contract_puzzle_hash": "0xc9423123ea65e6923e973b95531b4874570dae942cb757a2daec4a6971753886",
+        }
+    ],
+    "filter_prefix_bits": 3,
+}
+
+new_signage_point_harvester2_json: dict[str, Any] = {
     "challenge_hash": "0xe342c21b4aeaa52349d42492be934692db58494ca9bce4a8697d06fdf8e583bb",
     "difficulty": 15615706268399948682,
     "sub_slot_iters": 10520767421667792980,

chia/_tests/util/protocol_messages_json.py

@@ -431,163 +431,168 @@ def test_protocol_bytes() -> None:
     assert bytes(message_80) == bytes(new_signage_point_harvester)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_81 = type(new_proof_of_space).from_bytes(message_bytes)
-    assert message_81 == new_proof_of_space
-    assert bytes(message_81) == bytes(new_proof_of_space)
+    message_81 = type(new_signage_point_harvester2).from_bytes(message_bytes)
+    assert message_81 == new_signage_point_harvester2
+    assert bytes(message_81) == bytes(new_signage_point_harvester2)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_82 = type(request_signatures).from_bytes(message_bytes)
-    assert message_82 == request_signatures
-    assert bytes(message_82) == bytes(request_signatures)
+    message_82 = type(new_proof_of_space).from_bytes(message_bytes)
+    assert message_82 == new_proof_of_space
+    assert bytes(message_82) == bytes(new_proof_of_space)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_83 = type(respond_signatures).from_bytes(message_bytes)
-    assert message_83 == respond_signatures
-    assert bytes(message_83) == bytes(respond_signatures)
+    message_83 = type(request_signatures).from_bytes(message_bytes)
+    assert message_83 == request_signatures
+    assert bytes(message_83) == bytes(request_signatures)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_84 = type(plot).from_bytes(message_bytes)
-    assert message_84 == plot
-    assert bytes(message_84) == bytes(plot)
+    message_84 = type(respond_signatures).from_bytes(message_bytes)
+    assert message_84 == respond_signatures
+    assert bytes(message_84) == bytes(respond_signatures)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_85 = type(request_plots).from_bytes(message_bytes)
-    assert message_85 == request_plots
-    assert bytes(message_85) == bytes(request_plots)
+    message_85 = type(plot).from_bytes(message_bytes)
+    assert message_85 == plot
+    assert bytes(message_85) == bytes(plot)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_86 = type(respond_plots).from_bytes(message_bytes)
-    assert message_86 == respond_plots
-    assert bytes(message_86) == bytes(respond_plots)
+    message_86 = type(request_plots).from_bytes(message_bytes)
+    assert message_86 == request_plots
+    assert bytes(message_86) == bytes(request_plots)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_87 = type(request_peers_introducer).from_bytes(message_bytes)
-    assert message_87 == request_peers_introducer
-    assert bytes(message_87) == bytes(request_peers_introducer)
+    message_87 = type(respond_plots).from_bytes(message_bytes)
+    assert message_87 == respond_plots
+    assert bytes(message_87) == bytes(respond_plots)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_88 = type(respond_peers_introducer).from_bytes(message_bytes)
-    assert message_88 == respond_peers_introducer
-    assert bytes(message_88) == bytes(respond_peers_introducer)
+    message_88 = type(request_peers_introducer).from_bytes(message_bytes)
+    assert message_88 == request_peers_introducer
+    assert bytes(message_88) == bytes(request_peers_introducer)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_89 = type(authentication_payload).from_bytes(message_bytes)
-    assert message_89 == authentication_payload
-    assert bytes(message_89) == bytes(authentication_payload)
+    message_89 = type(respond_peers_introducer).from_bytes(message_bytes)
+    assert message_89 == respond_peers_introducer
+    assert bytes(message_89) == bytes(respond_peers_introducer)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_90 = type(get_pool_info_response).from_bytes(message_bytes)
-    assert message_90 == get_pool_info_response
-    assert bytes(message_90) == bytes(get_pool_info_response)
+    message_90 = type(authentication_payload).from_bytes(message_bytes)
+    assert message_90 == authentication_payload
+    assert bytes(message_90) == bytes(authentication_payload)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_91 = type(post_partial_payload).from_bytes(message_bytes)
-    assert message_91 == post_partial_payload
-    assert bytes(message_91) == bytes(post_partial_payload)
+    message_91 = type(get_pool_info_response).from_bytes(message_bytes)
+    assert message_91 == get_pool_info_response
+    assert bytes(message_91) == bytes(get_pool_info_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_92 = type(post_partial_request).from_bytes(message_bytes)
-    assert message_92 == post_partial_request
-    assert bytes(message_92) == bytes(post_partial_request)
+    message_92 = type(post_partial_payload).from_bytes(message_bytes)
+    assert message_92 == post_partial_payload
+    assert bytes(message_92) == bytes(post_partial_payload)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_93 = type(post_partial_response).from_bytes(message_bytes)
-    assert message_93 == post_partial_response
-    assert bytes(message_93) == bytes(post_partial_response)
+    message_93 = type(post_partial_request).from_bytes(message_bytes)
+    assert message_93 == post_partial_request
+    assert bytes(message_93) == bytes(post_partial_request)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_94 = type(get_farmer_response).from_bytes(message_bytes)
-    assert message_94 == get_farmer_response
-    assert bytes(message_94) == bytes(get_farmer_response)
+    message_94 = type(post_partial_response).from_bytes(message_bytes)
+    assert message_94 == post_partial_response
+    assert bytes(message_94) == bytes(post_partial_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_95 = type(post_farmer_payload).from_bytes(message_bytes)
-    assert message_95 == post_farmer_payload
-    assert bytes(message_95) == bytes(post_farmer_payload)
+    message_95 = type(get_farmer_response).from_bytes(message_bytes)
+    assert message_95 == get_farmer_response
+    assert bytes(message_95) == bytes(get_farmer_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_96 = type(post_farmer_request).from_bytes(message_bytes)
-    assert message_96 == post_farmer_request
-    assert bytes(message_96) == bytes(post_farmer_request)
+    message_96 = type(post_farmer_payload).from_bytes(message_bytes)
+    assert message_96 == post_farmer_payload
+    assert bytes(message_96) == bytes(post_farmer_payload)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_97 = type(post_farmer_response).from_bytes(message_bytes)
-    assert message_97 == post_farmer_response
-    assert bytes(message_97) == bytes(post_farmer_response)
+    message_97 = type(post_farmer_request).from_bytes(message_bytes)
+    assert message_97 == post_farmer_request
+    assert bytes(message_97) == bytes(post_farmer_request)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_98 = type(put_farmer_payload).from_bytes(message_bytes)
-    assert message_98 == put_farmer_payload
-    assert bytes(message_98) == bytes(put_farmer_payload)
+    message_98 = type(post_farmer_response).from_bytes(message_bytes)
+    assert message_98 == post_farmer_response
+    assert bytes(message_98) == bytes(post_farmer_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_99 = type(put_farmer_request).from_bytes(message_bytes)
-    assert message_99 == put_farmer_request
-    assert bytes(message_99) == bytes(put_farmer_request)
+    message_99 = type(put_farmer_payload).from_bytes(message_bytes)
+    assert message_99 == put_farmer_payload
+    assert bytes(message_99) == bytes(put_farmer_payload)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_100 = type(put_farmer_response).from_bytes(message_bytes)
-    assert message_100 == put_farmer_response
-    assert bytes(message_100) == bytes(put_farmer_response)
+    message_100 = type(put_farmer_request).from_bytes(message_bytes)
+    assert message_100 == put_farmer_request
+    assert bytes(message_100) == bytes(put_farmer_request)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_101 = type(error_response).from_bytes(message_bytes)
-    assert message_101 == error_response
-    assert bytes(message_101) == bytes(error_response)
+    message_101 = type(put_farmer_response).from_bytes(message_bytes)
+    assert message_101 == put_farmer_response
+    assert bytes(message_101) == bytes(put_farmer_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_102 = type(new_peak_timelord).from_bytes(message_bytes)
-    assert message_102 == new_peak_timelord
-    assert bytes(message_102) == bytes(new_peak_timelord)
+    message_102 = type(error_response).from_bytes(message_bytes)
+    assert message_102 == error_response
+    assert bytes(message_102) == bytes(error_response)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_103 = type(new_unfinished_block_timelord).from_bytes(message_bytes)
-    assert message_103 == new_unfinished_block_timelord
-    assert bytes(message_103) == bytes(new_unfinished_block_timelord)
+    message_103 = type(new_peak_timelord).from_bytes(message_bytes)
+    assert message_103 == new_peak_timelord
+    assert bytes(message_103) == bytes(new_peak_timelord)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_104 = type(new_infusion_point_vdf).from_bytes(message_bytes)
-    assert message_104 == new_infusion_point_vdf
-    assert bytes(message_104) == bytes(new_infusion_point_vdf)
+    message_104 = type(new_unfinished_block_timelord).from_bytes(message_bytes)
+    assert message_104 == new_unfinished_block_timelord
+    assert bytes(message_104) == bytes(new_unfinished_block_timelord)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_105 = type(new_signage_point_vdf).from_bytes(message_bytes)
-    assert message_105 == new_signage_point_vdf
-    assert bytes(message_105) == bytes(new_signage_point_vdf)
+    message_105 = type(new_infusion_point_vdf).from_bytes(message_bytes)
+    assert message_105 == new_infusion_point_vdf
+    assert bytes(message_105) == bytes(new_infusion_point_vdf)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_106 = type(new_end_of_sub_slot_bundle).from_bytes(message_bytes)
-    assert message_106 == new_end_of_sub_slot_bundle
-    assert bytes(message_106) == bytes(new_end_of_sub_slot_bundle)
+    message_106 = type(new_signage_point_vdf).from_bytes(message_bytes)
+    assert message_106 == new_signage_point_vdf
+    assert bytes(message_106) == bytes(new_signage_point_vdf)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_107 = type(request_compact_proof_of_time).from_bytes(message_bytes)
-    assert message_107 == request_compact_proof_of_time
-    assert bytes(message_107) == bytes(request_compact_proof_of_time)
+    message_107 = type(new_end_of_sub_slot_bundle).from_bytes(message_bytes)
+    assert message_107 == new_end_of_sub_slot_bundle
+    assert bytes(message_107) == bytes(new_end_of_sub_slot_bundle)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_108 = type(respond_compact_proof_of_time).from_bytes(message_bytes)
-    assert message_108 == respond_compact_proof_of_time
-    assert bytes(message_108) == bytes(respond_compact_proof_of_time)
+    message_108 = type(request_compact_proof_of_time).from_bytes(message_bytes)
+    assert message_108 == request_compact_proof_of_time
+    assert bytes(message_108) == bytes(request_compact_proof_of_time)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_109 = type(error_without_data).from_bytes(message_bytes)
-    assert message_109 == error_without_data
-    assert bytes(message_109) == bytes(error_without_data)
+    message_109 = type(respond_compact_proof_of_time).from_bytes(message_bytes)
+    assert message_109 == respond_compact_proof_of_time
+    assert bytes(message_109) == bytes(respond_compact_proof_of_time)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_110 = type(error_with_data).from_bytes(message_bytes)
-    assert message_110 == error_with_data
-    assert bytes(message_110) == bytes(error_with_data)
+    message_110 = type(error_without_data).from_bytes(message_bytes)
+    assert message_110 == error_without_data
+    assert bytes(message_110) == bytes(error_without_data)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_111 = type(solver_info).from_bytes(message_bytes)
-    assert message_111 == solver_info
-    assert bytes(message_111) == bytes(solver_info)
+    message_111 = type(error_with_data).from_bytes(message_bytes)
+    assert message_111 == error_with_data
+    assert bytes(message_111) == bytes(error_with_data)
 
     message_bytes, input_bytes = parse_blob(input_bytes)
-    message_112 = type(solver_response).from_bytes(message_bytes)
-    assert message_112 == solver_response
-    assert bytes(message_112) == bytes(solver_response)
+    message_112 = type(solver_info).from_bytes(message_bytes)
+    assert message_112 == solver_info
+    assert bytes(message_112) == bytes(solver_info)
+
+    message_bytes, input_bytes = parse_blob(input_bytes)
+    message_113 = type(solver_response).from_bytes(message_bytes)
+    assert message_113 == solver_response
+    assert bytes(message_113) == bytes(solver_response)
 
     assert input_bytes == b""

chia/_tests/util/test_network_protocol_files.py

@@ -196,6 +196,11 @@ def test_protocol_json() -> None:
         type(new_signage_point_harvester).from_json_dict(new_signage_point_harvester_json)
         == new_signage_point_harvester
     )
+    assert str(new_signage_point_harvester2_json) == str(new_signage_point_harvester2.to_json_dict())
+    assert (
+        type(new_signage_point_harvester2).from_json_dict(new_signage_point_harvester2_json)
+        == new_signage_point_harvester2
+    )
     assert str(new_proof_of_space_json) == str(new_proof_of_space.to_json_dict())
     assert type(new_proof_of_space).from_json_dict(new_proof_of_space_json) == new_proof_of_space
     assert str(request_signatures_json) == str(request_signatures.to_json_dict())

chia/_tests/util/test_network_protocol_json.py

@@ -174,6 +174,7 @@ def test_missing_messages() -> None:
         "ProofOfSpaceFeeInfo",
         "NewProofOfSpace",
         "NewSignagePointHarvester",
+        "NewSignagePointHarvester2",
         "Plot",
         "PlotSyncDone",
         "PlotSyncError",