noisymime
/
chia-blockchain
mirror of https://github.com/noisymime/chia-blockchain.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix weight proof tests

This commit is contained in:
almog 2020-12-08 17:45:17 +02:00 committed by Yostra
parent 42955bb26b
commit b38c67489c
5 changed files with 45 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/full_node/full_node.py
View File

@ -306,7 +306,11 @@ class FullNode:
peers: List[WSChiaConnection] = self.server.get_full_node_connections()
# send weight proof message, continue on first response
fork_point_height = await self._fetch_and_validate_weight_proof(peak_hash, peers, target_peak_sb_height)
# fork_point_height = await self._fetch_and_validate_weight_proof(peak_hash, peers, target_peak_sb_height)
# if fork_point_height is None:
# self.log.error("failed to validate weight proof")
# return
fork_point_height = -1
self.sync_peers_handler = SyncPeersHandler(
self.sync_store, peers, fork_point_height, self.blockchain, target_peak_sb_height, self.server
@ -375,17 +379,23 @@ class FullNode:
f"{round((time.time() - sync_start_time)/60, 2)} minutes."
)
async def _fetch_and_validate_weight_proof(self, peak_hash, peers, target_peak_sb_height):
async def _fetch_and_validate_weight_proof(self, peak_hash, peers, target_peak_sb_height) -> Optional[uint32]:
response: Optional[Tuple[Any, WSChiaConnection]] = await send_all_first_reply(
"request_proof_of_weight", full_node_protocol.RequestProofOfWeight(target_peak_sb_height, peak_hash), peers
)
if response is None:
self.log.error("response was None")
return None
# if validated continue else fail
weight_proof: WeightProof = response[0].wp
if not self.weight_proof_handler.validate_weight_proof(weight_proof):
self.log.error(f"invalid weight proof {response}")
# return
self.log.error(
f"invalid weight proof, num of epochs {len(weight_proof.sub_epochs)}"
f" recent blocks num ,{len(weight_proof.recent_chain_data)}"
)
return None
# iterate through sub epoch summaries to find fork point
# todo change so we dont have to sort the dict
fork_point_height = -1

7
src/full_node/weight_proof.py
View File

@ -146,15 +146,20 @@ class WeightProofHandler:
rng: random.Random = random.Random(tip)
# ses_hash from the latest sub epoch summary before this part of the chain
sub_block_height = self.block_cache.sub_block_record(tip).sub_block_height
self.log.info(f"build weight proofs, peak : {sub_block_height} num of blocks: {total_number_of_blocks}")
assert sub_block_height >= total_number_of_blocks - 1
sub_epoch_n: uint32 = uint32(0)
blocks_left = total_number_of_blocks
curr_height = sub_block_height - (total_number_of_blocks - 1)
self.log.info(
f"build weight proofs, peak : {sub_block_height} num of blocks: {total_number_of_blocks}, start from {curr_height}"
)
total_overflow_blocks = 0
while curr_height < sub_block_height:
self.log.info(f"handle {curr_height}")
# next sub block
sub_block = self.block_cache.height_to_sub_block_record(curr_height)
header_block = self.block_cache.height_to_header_block(curr_height)

8
tests/full_node/fixtures.py
View File

@ -31,22 +31,22 @@ async def empty_blockchain():
bc1.shut_down()
@pytest.fixture(scope="module")
@pytest.fixture(scope="function")
async def default_400_blocks():
yield persistent_blocks(400, "test_blocks_400.db")
@pytest.fixture(scope="module")
@pytest.fixture(scope="function")
async def default_1000_blocks():
yield persistent_blocks(1000, "test_blocks_1000.db")
@pytest.fixture(scope="module")
@pytest.fixture(scope="function")
async def default_10000_blocks():
yield persistent_blocks(10000, "test_blocks_10000.db")
@pytest.fixture(scope="module")
@pytest.fixture(scope="function")
async def default_20000_blocks():
yield persistent_blocks(20000, "test_blocks_20000.db")

17
tests/full_node/test_full_sync.py
View File

@ -7,6 +7,7 @@ from src.protocols import full_node_protocol
from src.util.ints import uint16
from tests.setup_nodes import setup_two_nodes, test_constants, bt
from tests.time_out_assert import time_out_assert
from tests.full_node.fixtures import empty_blockchain, default_400_blocks, default_10000_blocks
def node_height_at_least(node, h):
@ -43,6 +44,22 @@ class TestFullSync:
# same tip at height num_blocks - 1 (or at least num_blocks - 3, in case we sync to below the tip)
await time_out_assert(60, node_height_at_least, True, full_node_2, num_blocks - 1)
# @pytest.mark.asyncio
# async def test_sync_with_sub_epochs(self, two_nodes, default_400_blocks):
# # Must be larger than "sync_block_behind_threshold" in the config
# num_blocks = len(default_400_blocks)
# blocks = default_400_blocks
# full_node_1, full_node_2, server_1, server_2 = two_nodes
#
# for block in blocks:
# await full_node_1.full_node.respond_sub_block(full_node_protocol.RespondSubBlock(block))
#
# await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
#
# # The second node should eventually catch up to the first one, and have the
# # same tip at height num_blocks - 1 (or at least num_blocks - 3, in case we sync to below the tip)
# await time_out_assert(60, node_height_at_least, True, full_node_2, num_blocks - 1)
@pytest.mark.asyncio
async def test_short_sync(self, two_nodes):
# Must be below "sync_block_behind_threshold" in the config

19
tests/full_node/test_weight_proof.py
View File

@ -49,7 +49,7 @@ def count_sub_epochs(blockchain, last_hash) -> int:
def get_prev_ses_block(sub_blocks, last_hash) -> (SubBlockRecord, int):
curr = sub_blocks[last_hash]
blocks = 0
blocks = 1
while True:
assert curr.sub_block_height != 0
# next sub block
@ -101,31 +101,23 @@ def load_blocks_dont_validate(blocks):
def _test_map_summaries(blocks, header_cache, height_to_hash, sub_blocks, sub_epochs):
sub_epoch_end, num_of_blocks = get_prev_ses_block(sub_blocks, blocks[-1].header_hash)
print("num of blocks to first ses: ", num_of_blocks)
sub_epochs_left = sub_epochs
curr = sub_epoch_end
curr = sub_blocks[blocks[-1].header_hash]
num_of_blocks = 1
orig_summaries: Dict[int, SubEpochSummary] = {}
while True:
if curr.sub_epoch_summary_included is not None:
print(
f"ses height {curr.sub_block_height} prev overflows {curr.sub_epoch_summary_included.num_sub_blocks_overflow}"
)
orig_summaries[sub_epochs_left - 1] = curr.sub_epoch_summary_included
sub_epochs_left -= 1
if sub_epochs_left <= 0:
break
# next sub block
curr = sub_blocks[curr.prev_hash]
num_of_blocks += 1
num_of_blocks += 1
curr = sub_blocks[curr.prev_hash]
print(f"fork point is {curr.sub_block_height} (not included)")
print(f"num of blocks in proof: {num_of_blocks}")
print(f"num of full sub epochs in proof: {sub_epochs}")
# print(f"{header_cache[height_to_hash[9810]].finished_sub_slots[-1].challenge_chain}")
# print(f"{sub_blocks[height_to_hash[9810]].sub_epoch_summary_included}")
wpf = WeightProofHandler(test_constants, BlockCacheMock(sub_blocks, height_to_hash, header_cache))
wpf.log.setLevel(logging.INFO)
initialize_logging("", {"log_stdout": True}, DEFAULT_ROOT_PATH)
@ -261,9 +253,6 @@ class TestWeightProof:
async def test_weight_proof_from_genesis(self, default_400_blocks):
blocks = default_400_blocks
header_cache, height_to_hash, sub_blocks = load_blocks_dont_validate(blocks)
sub_epoch_end, num_of_blocks = get_prev_ses_block(sub_blocks, blocks[-1].header_hash)
print("num of blocks to first ses: ", num_of_blocks)
curr = sub_epoch_end
wpf = WeightProofHandler(test_constants, BlockCacheMock(sub_blocks, height_to_hash, header_cache))
wpf.log.setLevel(logging.INFO)
initialize_logging("", {"log_stdout": True}, DEFAULT_ROOT_PATH)