chia-blockchain 2.5.5rc7__py3-none-any.whl → 2.5.6rc2__py3-none-any.whl

chia/_tests/util/build_network_protocol_files.py

@@ -117,6 +117,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

@@ -789,6 +789,16 @@ harvester_handhsake = harvester_protocol.HarvesterHandshake(
 )
 
 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),
@@ -799,6 +809,7 @@ new_signage_point_harvester = harvester_protocol.NewSignagePointHarvester(
     uint32(0),
 )
 
+
 new_proof_of_space = harvester_protocol.NewProofOfSpace(
     bytes32.fromhex("1b64ec6bf3fe33bb80eca5b64ff1c88be07771eaed1e98a7199510522087e56e"),
     bytes32.fromhex("ad1f8a74376ce8c5c93b7fbb355c2fb6d689ae4f4a7134166593d95265a3da30"),

chia/_tests/util/protocol_messages_json.py

@@ -2148,6 +2148,22 @@ harvester_handhsake_json: dict[str, Any] = {
 }
 
 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/test_network_protocol_files.py

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

chia/_tests/util/test_network_protocol_json.py

@@ -194,6 +194,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_test.py

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

chia/farmer/farmer_api.py

@@ -6,9 +6,10 @@ import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 
 import aiohttp
-from chia_rs import AugSchemeMPL, G2Element, PoolTarget, PrivateKey
+from chia_rs import AugSchemeMPL, G2Element, PlotSize, PoolTarget, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
+from packaging.version import Version
 
 from chia import __version__
 from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters
@@ -38,6 +39,7 @@ from chia.server.server import ssl_context_for_root
 from chia.server.ws_connection import WSChiaConnection
 from chia.ssl.create_ssl import get_mozilla_ca_crt
 from chia.types.blockchain_format.proof_of_space import (
+    calculate_prefix_bits,
     generate_plot_public_key,
     generate_taproot_sk,
     get_plot_id,
@@ -528,7 +530,8 @@ class FarmerAPI:
                         p2_singleton_puzzle_hash,
                     )
                 )
-            message = harvester_protocol.NewSignagePointHarvester(
+
+            message2 = harvester_protocol.NewSignagePointHarvester2(
                 new_signage_point.challenge_hash,
                 new_signage_point.difficulty,
                 new_signage_point.sub_slot_iters,
@@ -539,8 +542,31 @@ class FarmerAPI:
                 new_signage_point.last_tx_height,
             )
 
-            msg = make_msg(ProtocolMessageTypes.new_signage_point_harvester, message)
-            await self.farmer.server.send_to_all([msg], NodeType.HARVESTER)
+            # The plot size in the call to calculate_prefix_bits is only used
+            # to distinguish v1 and v2 plots. The value does not matter
+            message1 = harvester_protocol.NewSignagePointHarvester(
+                new_signage_point.challenge_hash,
+                new_signage_point.difficulty,
+                new_signage_point.sub_slot_iters,
+                new_signage_point.signage_point_index,
+                new_signage_point.challenge_chain_sp,
+                pool_difficulties,
+                uint8(
+                    calculate_prefix_bits(self.farmer.constants, new_signage_point.peak_height, PlotSize.make_v1(32))
+                ),
+            )
+
+            def old_harvesters(conn: WSChiaConnection) -> bool:
+                return conn.protocol_version <= Version("0.0.36")
+
+            def new_harvesters(conn: WSChiaConnection) -> bool:
+                return conn.protocol_version > Version("0.0.36")
+
+            msg1 = make_msg(ProtocolMessageTypes.new_signage_point_harvester, message1)
+            await self.farmer.server.send_to_all_if([msg1], NodeType.HARVESTER, old_harvesters)
+
+            msg2 = make_msg(ProtocolMessageTypes.new_signage_point_harvester, message2)
+            await self.farmer.server.send_to_all_if([msg2], NodeType.HARVESTER, new_harvesters)
         except Exception as exception:
             # Remove here, as we want to reprocess the SP should it be sent again
             self.farmer.sps[new_signage_point.challenge_chain_sp].remove(new_signage_point)

chia/harvester/harvester_api.py

@@ -65,9 +65,9 @@ class HarvesterAPI:
         await self.harvester.plot_sync_sender.start()
         self.harvester.plot_manager.start_refreshing()
 
-    @metadata.request(peer_required=True)
+    @metadata.request(peer_required=True, request_type=ProtocolMessageTypes.new_signage_point_harvester)
     async def new_signage_point_harvester(
-        self, new_challenge: harvester_protocol.NewSignagePointHarvester, peer: WSChiaConnection
+        self, new_challenge: harvester_protocol.NewSignagePointHarvester2, peer: WSChiaConnection
     ) -> None:
         """
         The harvester receives a new signage point from the farmer, this happens at the start of each slot.

chia/protocols/harvester_protocol.py

@@ -34,6 +34,20 @@ class HarvesterHandshake(Streamable):
 @streamable
 @dataclass(frozen=True)
 class NewSignagePointHarvester(Streamable):
+    challenge_hash: bytes32
+    difficulty: uint64
+    sub_slot_iters: uint64
+    signage_point_index: uint8
+    sp_hash: bytes32
+    pool_difficulties: list[PoolDifficulty]
+    filter_prefix_bits: uint8
+
+
+# this message has the same message ID as NewSignagePointHarvester, but this
+# message format is used if the protocol version is 0.0.37 or higher
+@streamable
+@dataclass(frozen=True)
+class NewSignagePointHarvester2(Streamable):
     challenge_hash: bytes32
     difficulty: uint64
     sub_slot_iters: uint64

{chia_blockchain-2.5.5rc7.dist-info → chia_blockchain-2.5.6rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: chia-blockchain
-Version: 2.5.5rc7
+Version: 2.5.6rc2
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 License: Apache-2.0
 Keywords: chia,blockchain,node

{chia_blockchain-2.5.5rc7.dist-info → chia_blockchain-2.5.6rc2.dist-info}/RECORD

@@ -260,7 +260,7 @@ chia/_tests/util/benchmarks.py,sha256=0cl147e492XFhU8Ehj41oFW3mNM8nH-sKymw3i-4mv
 chia/_tests/util/bip39_test_vectors.json,sha256=dMvohwzIzOVHKz0eOSUH7MJiL5BiDwp-EP9C4_VmN50,10283
 chia/_tests/util/blockchain.py,sha256=mEkmyEUXZr9sG1poG0L5OLA7PW82XuhRS9mu84Iq67Y,5367
 chia/_tests/util/blockchain_mock.py,sha256=Kq5wcPwjIk717hmrZ5HPUUDGaMaVnbMziZSo2SQqxio,4964
-chia/_tests/util/build_network_protocol_files.py,sha256=mVMT6vXHfwtcDi2PKrW3-ujMBZ2TMc37F_Exw-wzJG0,11225
+chia/_tests/util/build_network_protocol_files.py,sha256=HX_f_t8UfkxsZmvIi2vDH5zmub7X3U-Z9c79RPgcAaI,11299
 chia/_tests/util/clvm_generator.bin,sha256=ELP6vjY8NcvkdwA5EbLl34oRH5RuQwoPRYnMoY8yQS0,121543
 chia/_tests/util/coin_store.py,sha256=1DrlY9dTTewc13ZOhK-MbIr6efn6i1Eq8RoQngtLHtk,1116
 chia/_tests/util/config.py,sha256=TnSXuVC5W08HFB6LzmAU0fznQn7HZJCMqFETMafVLeg,53
@@ -272,9 +272,9 @@ chia/_tests/util/generator_tools_testing.py,sha256=o51smSD-2TMGdYLCxZQCDuK8dL5lO
 chia/_tests/util/get_name_puzzle_conditions.py,sha256=tTHn2YckaixWT8e8gGe0KBKVEsXq1IjoXvu2GEFlZeU,1493
 chia/_tests/util/key_tool.py,sha256=3IJx5dHZJ3yV4hxoF6MEGE6jC4GIo_MWkSRmIeaQnzQ,1576
 chia/_tests/util/misc.py,sha256=QdiaFsMNcq4-GSZNMYoHDAjyAgEkHK_V13q9vNt153Q,21614
-chia/_tests/util/network_protocol_data.py,sha256=knqTPfN9AUTV0Vb1KM4OTrnbc4EhWWBNSXAuvsKDTv4,37446
-chia/_tests/util/protocol_messages_bytes-v1.0,sha256=xwSlyG3aROl7kNgFZj_7pi13Og84t9w-m9KbrUXuMb8,50571
-chia/_tests/util/protocol_messages_json.py,sha256=OyY10fJYEylDOnbXBNn3dd3WQbo7CXC0vuHxfHJO7gI,182378
+chia/_tests/util/network_protocol_data.py,sha256=zKY3iD0nqorMuZvLXUbmyyA0CJlvW5-C0qcC_eFQRb0,37840
+chia/_tests/util/protocol_messages_bytes-v1.0,sha256=x7DvuJlS3fQFMc-AUJq_xDxfb1jDw4CYhVL-H83Fn6A,50709
+chia/_tests/util/protocol_messages_json.py,sha256=3IciZgUZcZGIWpolRsZVPDkOT61NYxPNiK5Z0OzTvKk,183022
 chia/_tests/util/rpc.py,sha256=g-vf7Nnp9Myr588lR2uyRs12eeQ1FIJ73h4FTFqiUeo,825
 chia/_tests/util/run_block.py,sha256=voyn8JJnGaG_M6QrdSB21lZ79I9ocFXtrXruo9cDgaI,5929
 chia/_tests/util/setup_nodes.py,sha256=_V0iddxULqWF1WQ8aSTN4KqXjJVZcXifEPbihnGWFYE,18409
@@ -297,9 +297,9 @@ chia/_tests/util/test_limited_semaphore.py,sha256=r2XPXc7vhdDzlwcEz9MRYmbZPs-BM3
 chia/_tests/util/test_logging_filter.py,sha256=omO-zPdaoR4vDAUeR-Ar2WNlREyxAnr4rP9HaYoloVo,1239
 chia/_tests/util/test_misc.py,sha256=vXPEoamAfTGMM55u1nxlMCO6pvUyVeH0qNzJs9_x1EI,13918
 chia/_tests/util/test_network.py,sha256=VM1mqnJ062bzdUxMnEYs0CeKjDlZclXglSpaminTmQM,2898
-chia/_tests/util/test_network_protocol_files.py,sha256=BgZP1xWM7J1Q6ZSY1LoM610PV9JFLDFdiaBtbDhxHwo,26518
-chia/_tests/util/test_network_protocol_json.py,sha256=nzp1DHdT7wgpPlVGh5QD_K_KvbmMmkL4aXbwWax_dh8,21326
-chia/_tests/util/test_network_protocol_test.py,sha256=gjGPLb6NDj0z-2XdQIh7KKA7suhelprmJsBfAGWW4Ic,8219
+chia/_tests/util/test_network_protocol_files.py,sha256=HBkbpfkc3ATZG1S4PUshxgRBPOGZJ8nGPMx6teGeAq0,26779
+chia/_tests/util/test_network_protocol_json.py,sha256=P86ggVruqS4uspMhQXWbjmh5Fv5Ar1Bh5ofdnDikZus,21580
+chia/_tests/util/test_network_protocol_test.py,sha256=ERejqj833K-fmNzjdNpa3SO0iNA3YJ1dAwoXPc9Z36s,8256
 chia/_tests/util/test_paginator.py,sha256=IXiFXy9dccLsQNL1q_N4R4uMx42w2IZegIRmBFvCgjw,2304
 chia/_tests/util/test_pprint.py,sha256=sgi0nIJjJopbxZV5VVQmurorsi6spTpTHpIdgaPlKls,660
 chia/_tests/util/test_priority_mutex.py,sha256=jD_R_W7WE9Cvje_qerttipwI51U9-9sfsSOX7xfcdYs,16219
@@ -516,7 +516,7 @@ chia/data_layer/util/benchmark.py,sha256=sdP_kQYNxySJVDVGrMG9P99QStAMUC4OLnUFqpH
 chia/data_layer/util/plugin.py,sha256=jsU654JfiAsIy2rsAXPSnN9bU3usYJrRYY5m7yGccKU,1567
 chia/farmer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/farmer/farmer.py,sha256=JLO0_fdfQJAZpE1wt6dbpNF31dPCL5dg6hu28sZt9eA,45123
-chia/farmer/farmer_api.py,sha256=I7vrFaaFr2b61dvNL5DSSjaCgLCkRvmoYO4okCnxeGM,40111
+chia/farmer/farmer_api.py,sha256=_LlWMpUIYna6cg_eQ2mIv37oO27DWNugQ-qEAiEBvpg,41340
 chia/farmer/farmer_rpc_api.py,sha256=OzA_-9-3rUenp1ucli0f--8sV2UhmVb6nNFSc5iSj1o,14231
 chia/farmer/farmer_rpc_client.py,sha256=TEsS5A_-LjrdfPIOX3UnMNPeZkhGpw3sj9w7ZZGW7aI,3928
 chia/full_node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -553,7 +553,7 @@ chia/full_node/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 chia/full_node/weight_proof.py,sha256=yTtTag1hemH3gw6K9XwFBPLWliAuzde5kY4zS-6V_pU,71307
 chia/harvester/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/harvester/harvester.py,sha256=oJOH9l8ymSqPraqWlWzWf0vBGBbM2CFkgFOfOEXSpeE,11828
-chia/harvester/harvester_api.py,sha256=F_95hNNexuXY2ejv9ZwdF-qtiN2-pEsoLxqObpWDDCg,19274
+chia/harvester/harvester_api.py,sha256=I3q8z6HNNA0oEs_mOf6gP4AgC_foFiLwW-zlkcEWZdc,19338
 chia/harvester/harvester_rpc_api.py,sha256=N3o5PIgtEHSwxrLWw1pV-qDQb8JUfeu054FckK23MzE,6643
 chia/harvester/harvester_rpc_client.py,sha256=T1o_-Le1SMLTCEZ8Cnt8nC42UMD-92qU0w60ZPvgtSc,2262
 chia/introducer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -588,7 +588,7 @@ chia/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chia/protocols/farmer_protocol.py,sha256=Dv8tZpiQEkIjsay8WxP7uXcGBLkJCPySGPu--I4lWmo,2795
 chia/protocols/fee_estimate.py,sha256=vKeArjfEjOEuwGpV0dDXOYbVJUQmb3E8LVfaGs-SmPI,1795
 chia/protocols/full_node_protocol.py,sha256=rlo2MosotA5YCRqiB7kzOE5yn2NKpQRGHM-AB6I8mzs,4427
-chia/protocols/harvester_protocol.py,sha256=cOaouqDgqG9Zqn6-lnA70h02OL0s4Gy54YuedUSMOXw,5583
+chia/protocols/harvester_protocol.py,sha256=gjJzsZ7EJ0tHyfMS2LcvLiUwk24EK5Fy-dRXDjsSjao,6016
 chia/protocols/introducer_protocol.py,sha256=qx-LGovClxzlqqrzFdrIiTps1-froMauD6HLEGZE1nQ,576
 chia/protocols/outbound_message.py,sha256=Wkl-l8o_9LXZi5HFlamIdrg0BmpX4SL7LvBj2TNbVnE,825
 chia/protocols/pool_protocol.py,sha256=LiZWLX6nzghUr74yWjl96RRObok2jtWvnrr5JQALqLo,3989
@@ -891,8 +891,8 @@ chia/wallet/wallet_user_store.py,sha256=rXiQpk5g8t1X0Chx0bValcQsHonjB1oQ_F_K16bp
 chia/wallet/wallet_weight_proof_handler.py,sha256=IcQg_w8EPjpS9xwmEE8GvPcneLePOtu74wWUu1l5uuM,4875
 chia/wallet/wsm_apis.py,sha256=6LmxbHXC-tqNbRyoiGgz-f19PF1nEfMbfm3BTnsNQ6s,3914
 mozilla-ca/cacert.pem,sha256=qz7jZRl3pBeKcCsLgopO57K7uRJyNbCrdA4uFZdL9ds,222971
-chia_blockchain-2.5.5rc7.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
-chia_blockchain-2.5.5rc7.dist-info/METADATA,sha256=zsp7-Z7j067pBbewUX5mnDnte--rz4lTIWXfimuYKKE,10687
-chia_blockchain-2.5.5rc7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-chia_blockchain-2.5.5rc7.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
-chia_blockchain-2.5.5rc7.dist-info/RECORD,,
+chia_blockchain-2.5.6rc2.dist-info/LICENSE,sha256=0tuU-jTzeRDJJaxF2YCEpBwbywgpbrVSXq1i6fJq63U,11347
+chia_blockchain-2.5.6rc2.dist-info/METADATA,sha256=9OJhXaCgt-WjlWsPrPnsCoifk2J_V_JPx1YoT5-7Zeg,10687
+chia_blockchain-2.5.6rc2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+chia_blockchain-2.5.6rc2.dist-info/entry_points.txt,sha256=GL2-UvicPVdKz72IP4shnmV3XImfoD5pMzoURfoAYk4,742
+chia_blockchain-2.5.6rc2.dist-info/RECORD,,