p2p_headers_sync_with_minchainwork.py raw
1 #!/usr/bin/env python3
2 # Copyright (c) 2019-present The Bitcoin Core developers
3 # Distributed under the MIT software license, see the accompanying
4 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 """Test that we reject low difficulty headers to prevent our block tree from filling up with useless bloat"""
6
7 from test_framework.test_framework import BitcoinTestFramework
8
9 from test_framework.p2p import (
10 P2PInterface,
11 )
12
13 from test_framework.messages import (
14 msg_headers,
15 )
16
17 from test_framework.blocktools import (
18 NORMAL_GBT_REQUEST_PARAMS,
19 create_block,
20 )
21
22 from test_framework.util import assert_equal
23
24 import time
25
26 NODE1_BLOCKS_REQUIRED = 15
27 NODE2_BLOCKS_REQUIRED = 2047
28
29
30 class RejectLowDifficultyHeadersTest(BitcoinTestFramework):
31 def set_test_params(self):
32 self.rpc_timeout *= 4 # To avoid timeout when generating BLOCKS_TO_MINE
33 self.setup_clean_chain = True
34 self.num_nodes = 4
35 # Node0 has no required chainwork; node1 requires 15 blocks on top of the genesis block; node2 requires 2047
36 self.extra_args = [["-minimumchainwork=0x0", "-checkblockindex=0"], ["-minimumchainwork=0x1f", "-checkblockindex=0"], ["-minimumchainwork=0x1000", "-checkblockindex=0"], ["-minimumchainwork=0x1000", "-checkblockindex=0", "-whitelist=noban@127.0.0.1"]]
37
38 def setup_network(self):
39 self.setup_nodes()
40 self.reconnect_all()
41 self.sync_all()
42
43 def disconnect_all(self):
44 self.disconnect_nodes(0, 1)
45 self.disconnect_nodes(0, 2)
46 self.disconnect_nodes(0, 3)
47
48 def reconnect_all(self):
49 self.connect_nodes(0, 1)
50 self.connect_nodes(0, 2)
51 self.connect_nodes(0, 3)
52
53 def mocktime_all(self, time):
54 for n in self.nodes:
55 n.setmocktime(time)
56
57 def test_chains_sync_when_long_enough(self):
58 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")
59 with (
60 self.nodes[1].assert_debug_log(expected_msgs=["[net] Ignoring low-work chain (height=14)"], timeout=2),
61 self.nodes[2].assert_debug_log(expected_msgs=["[net] Ignoring low-work chain (height=14)"], timeout=2),
62 self.nodes[3].assert_debug_log(expected_msgs=["Synchronizing blockheaders, height: 14"], timeout=2),
63 ):
64 self.generate(self.nodes[0], NODE1_BLOCKS_REQUIRED-1, sync_fun=self.no_op)
65
66 # Node3 should always allow headers due to noban permissions
67 self.log.info("Check that node3 will sync headers (due to noban permissions)")
68
69 def check_node3_chaintips(num_tips, tip_hash, height):
70 node3_chaintips = self.nodes[3].getchaintips()
71 assert_equal(len(node3_chaintips), num_tips)
72 assert {
73 'height': height,
74 'hash': tip_hash,
75 'branchlen': height,
76 'status': 'headers-only',
77 } in node3_chaintips
78
79 check_node3_chaintips(2, self.nodes[0].getbestblockhash(), NODE1_BLOCKS_REQUIRED-1)
80
81 for node in self.nodes[1:3]:
82 chaintips = node.getchaintips()
83 assert_equal(len(chaintips), 1)
84 assert {
85 'height': 0,
86 'hash': '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206',
87 'branchlen': 0,
88 'status': 'active',
89 } in chaintips
90
91 self.log.info("Generate more blocks to satisfy node1's minchainwork requirement, and verify node2 still has no new headers in headers tree")
92 with (
93 self.nodes[2].assert_debug_log(expected_msgs=["[net] Ignoring low-work chain (height=15)"], timeout=2),
94 self.nodes[3].assert_debug_log(expected_msgs=["Synchronizing blockheaders, height: 15"], timeout=2),
95 ):
96 self.generate(self.nodes[0], NODE1_BLOCKS_REQUIRED - self.nodes[0].getblockcount(), sync_fun=self.no_op)
97 self.sync_blocks(self.nodes[0:2]) # node3 will sync headers (noban permissions) but not blocks (due to minchainwork)
98
99 assert {
100 'height': 0,
101 'hash': '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206',
102 'branchlen': 0,
103 'status': 'active',
104 } in self.nodes[2].getchaintips()
105
106 assert_equal(len(self.nodes[2].getchaintips()), 1)
107
108 self.log.info("Check that node3 accepted these headers as well")
109 check_node3_chaintips(2, self.nodes[0].getbestblockhash(), NODE1_BLOCKS_REQUIRED)
110
111 self.log.info("Generate long chain for node0/node1/node3")
112 self.generate(self.nodes[0], NODE2_BLOCKS_REQUIRED-self.nodes[0].getblockcount(), sync_fun=self.no_op)
113
114 self.log.info("Verify that node2 and node3 will sync the chain when it gets long enough")
115 self.sync_blocks()
116
117 def test_peerinfo_includes_headers_presync_height(self):
118 self.log.info("Test that getpeerinfo() includes headers presync height")
119
120 # Disconnect network, so that we can find our own peer connection more
121 # easily
122 self.disconnect_all()
123
124 p2p = self.nodes[0].add_p2p_connection(P2PInterface())
125 node = self.nodes[0]
126
127 # Ensure we have a long chain already
128 current_height = self.nodes[0].getblockcount()
129 if (current_height < 3000):
130 self.generate(node, 3000-current_height, sync_fun=self.no_op)
131
132 # Send a group of 2000 headers, forking from genesis.
133 new_blocks = []
134 hashPrevBlock = int(node.getblockhash(0), 16)
135 for i in range(2000):
136 block = create_block(hashprev = hashPrevBlock, tmpl=node.getblocktemplate(NORMAL_GBT_REQUEST_PARAMS))
137 block.solve()
138 new_blocks.append(block)
139 hashPrevBlock = block.hash_int
140
141 headers_message = msg_headers(headers=new_blocks)
142 p2p.send_and_ping(headers_message)
143
144 # getpeerinfo should show a sync in progress
145 assert_equal(node.getpeerinfo()[0]['presynced_headers'], 2000)
146
147 def test_large_reorgs_can_succeed(self):
148 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")
149
150 self.sync_all() # Ensure all nodes are synced.
151 self.disconnect_all()
152
153 # locator(block at height T) will have heights:
154 # [T, T-1, ..., T-10, T-12, T-16, T-24, T-40, T-72, T-136, T-264,
155 # T-520, T-1032, T-2056, T-4104, ...]
156 # So mine a number of blocks > 4104 to ensure that the first window of
157 # received headers during a sync are fully between locator entries.
158 BLOCKS_TO_MINE = 4110
159
160 self.generate(self.nodes[0], BLOCKS_TO_MINE, sync_fun=self.no_op)
161 self.generate(self.nodes[1], BLOCKS_TO_MINE+2, sync_fun=self.no_op)
162
163 self.reconnect_all()
164
165 self.mocktime_all(int(time.time())) # Temporarily hold time to avoid internal timeouts
166 self.sync_blocks(timeout=300) # Ensure tips eventually agree
167 self.mocktime_all(0)
168
169
170 def run_test(self):
171 self.test_chains_sync_when_long_enough()
172
173 self.test_large_reorgs_can_succeed()
174
175 self.test_peerinfo_includes_headers_presync_height()
176
177
178
179 if __name__ == '__main__':
180 RejectLowDifficultyHeadersTest(__file__).main()
181