diff --git a/test/functional/p2p_headers_sync_with_minchainwork.py b/test/functional/p2p_headers_sync_with_minchainwork.py
index 52eeca847..ceefd8f1f 100755
--- a/test/functional/p2p_headers_sync_with_minchainwork.py
+++ b/test/functional/p2p_headers_sync_with_minchainwork.py
@@ -1,160 +1,162 @@
#!/usr/bin/env python3
# Copyright (c) 2019-2021 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test that we reject low difficulty headers to prevent our block tree from filling up with useless bloat"""
from test_framework.blocktools import create_block
from test_framework.messages import msg_headers
from test_framework.p2p import P2PInterface
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal
NODE1_BLOCKS_REQUIRED = 15
NODE2_BLOCKS_REQUIRED = 2047
class RejectLowDifficultyHeadersTest(BitcoinTestFramework):
def set_test_params(self):
+ # Bump the timeout to avoid timeout when generating BLOCKS_TO_MINE
+ self.rpc_timeout *= 4
self.setup_clean_chain = True
self.num_nodes = 3
# Node0 has no required chainwork; node1 requires 15 blocks on top of the
# genesis block; node2 requires 2047
self.extra_args = [
["-minimumchainwork=0x0", "-checkblockindex=0", "-noparkdeepreorg"],
["-minimumchainwork=0x1f", "-checkblockindex=0", "-noparkdeepreorg"],
["-minimumchainwork=0x1000", "-checkblockindex=0", "-noparkdeepreorg"],
]
def setup_network(self):
self.setup_nodes()
self.reconnect_all()
self.sync_all()
def disconnect_all(self):
self.disconnect_nodes(0, 1)
self.disconnect_nodes(0, 2)
def reconnect_all(self):
self.connect_nodes(0, 1)
self.connect_nodes(0, 2)
def test_chains_sync_when_long_enough(self):
self.log.info(
"Generate blocks on the node with no required chainwork, and verify nodes "
"1 and 2 have no new headers in their headers tree"
)
with self.nodes[1].assert_debug_log(
expected_msgs=["Ignoring low-work chain (height=14)"]
), self.nodes[2].assert_debug_log(
expected_msgs=["Ignoring low-work chain (height=14)"]
):
self.generate(self.nodes[0], NODE1_BLOCKS_REQUIRED - 1, sync_fun=self.no_op)
for node in self.nodes[1:]:
chaintips = node.getchaintips()
assert len(chaintips) == 1
assert {
"height": 0,
"hash": "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
"branchlen": 0,
"status": "active",
} in chaintips
self.log.info(
"Generate more blocks to satisfy node1's minchainwork requirement, and "
"verify node2 still has no new headers in headers tree"
)
with self.nodes[2].assert_debug_log(
expected_msgs=["Ignoring low-work chain (height=15)"]
):
self.generate(
self.nodes[0],
NODE1_BLOCKS_REQUIRED - self.nodes[0].getblockcount(),
sync_fun=self.no_op,
)
self.sync_blocks(self.nodes[0:2])
assert {
"height": 0,
"hash": "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
"branchlen": 0,
"status": "active",
} in self.nodes[2].getchaintips()
assert len(self.nodes[2].getchaintips()) == 1
self.log.info("Generate long chain for node0/node1")
self.generate(
self.nodes[0],
NODE2_BLOCKS_REQUIRED - self.nodes[0].getblockcount(),
sync_fun=self.no_op,
)
self.log.info("Verify that node2 will sync the chain when it gets long enough")
self.sync_blocks()
def test_peerinfo_includes_headers_presync_height(self):
self.log.info("Test that getpeerinfo() includes headers presync height")
# Disconnect network, so that we can find our own peer connection more
# easily
self.disconnect_all()
p2p = self.nodes[0].add_p2p_connection(P2PInterface())
node = self.nodes[0]
# Ensure we have a long chain already
current_height = self.nodes[0].getblockcount()
if current_height < 3000:
self.generate(node, 3000 - current_height, sync_fun=self.no_op)
# Send a group of 2000 headers, forking from genesis.
new_blocks = []
hashPrevBlock = int(node.getblockhash(0), 16)
for i in range(2000):
block = create_block(hashprev=hashPrevBlock, tmpl=node.getblocktemplate())
block.solve()
new_blocks.append(block)
hashPrevBlock = block.sha256
headers_message = msg_headers(headers=new_blocks)
p2p.send_and_ping(headers_message)
# getpeerinfo should show a sync in progress
assert_equal(node.getpeerinfo()[0]["presynced_headers"], 2000)
def test_large_reorgs_can_succeed(self):
self.log.info(
"Test that a 2000+ block reorg, starting from a point that is more than "
"2000 blocks before a locator entry, can succeed"
)
# Ensure all nodes are synced.
self.sync_all()
self.disconnect_all()
# locator(block at height T) will have heights:
# [T, T-1, ..., T-10, T-12, T-16, T-24, T-40, T-72, T-136, T-264,
# T-520, T-1032, T-2056, T-4104, ...]
# So mine a number of blocks > 4104 to ensure that the first window of
# received headers during a sync are fully between locator entries.
BLOCKS_TO_MINE = 4110
self.generate(self.nodes[0], BLOCKS_TO_MINE, sync_fun=self.no_op)
self.generate(self.nodes[1], BLOCKS_TO_MINE + 2, sync_fun=self.no_op)
self.reconnect_all()
# Ensure tips eventually agree
self.sync_blocks(timeout=300)
def run_test(self):
self.test_chains_sync_when_long_enough()
self.test_large_reorgs_can_succeed()
self.test_peerinfo_includes_headers_presync_height()
if __name__ == "__main__":
RejectLowDifficultyHeadersTest().main()