ttest_blockchain.py - electrum - Electrum Bitcoin wallet
HTML git clone https://git.parazyd.org/electrum
DIR Log
DIR Files
DIR Refs
DIR Submodules
---
ttest_blockchain.py (26214B)
---
1 import shutil
2 import tempfile
3 import os
4
5 from electrum import constants, blockchain
6 from electrum.simple_config import SimpleConfig
7 from electrum.blockchain import Blockchain, deserialize_header, hash_header
8 from electrum.util import bh2u, bfh, make_dir
9
10 from . import ElectrumTestCase
11
12
13 class TestBlockchain(ElectrumTestCase):
14
15 HEADERS = {
16 'A': deserialize_header(bfh("0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff7f2002000000"), 0),
17 'B': deserialize_header(bfh("0000002006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f186c8dfd970a4545f79916bc1d75c9d00432f57c89209bf3bb115b7612848f509c25f45bffff7f2000000000"), 1),
18 'C': deserialize_header(bfh("00000020686bdfc6a3db73d5d93e8c9663a720a26ecb1ef20eb05af11b36cdbc57c19f7ebf2cbf153013a1c54abaf70e95198fcef2f3059cc6b4d0f7e876808e7d24d11cc825f45bffff7f2000000000"), 2),
19 'D': deserialize_header(bfh("00000020122baa14f3ef54985ae546d1611559e3f487bd2a0f46e8dbb52fbacc9e237972e71019d7feecd9b8596eca9a67032c5f4641b23b5d731dc393e37de7f9c2f299e725f45bffff7f2000000000"), 3),
20 'E': deserialize_header(bfh("00000020f8016f7ef3a17d557afe05d4ea7ab6bde1b2247b7643896c1b63d43a1598b747a3586da94c71753f27c075f57f44faf913c31177a0957bbda42e7699e3a2141aed25f45bffff7f2001000000"), 4),
21 'F': deserialize_header(bfh("000000201d589c6643c1d121d73b0573e5ee58ab575b8fdf16d507e7e915c5fbfbbfd05e7aee1d692d1615c3bdf52c291032144ce9e3b258a473c17c745047f3431ff8e2ee25f45bffff7f2000000000"), 5),
22 'O': deserialize_header(bfh("00000020b833ed46eea01d4c980f59feee44a66aa1162748b6801029565d1466790c405c3a141ce635cbb1cd2b3a4fcdd0a3380517845ba41736c82a79cab535d31128066526f45bffff7f2001000000"), 6),
23 'P': deserialize_header(bfh("00000020abe8e119d1877c9dc0dc502d1a253fb9a67967c57732d2f71ee0280e8381ff0a9690c2fe7c1a4450c74dc908fe94dd96c3b0637d51475e9e06a78e944a0c7fe28126f45bffff7f2000000000"), 7),
24 'Q': deserialize_header(bfh("000000202ce41d94eb70e1518bc1f72523f84a903f9705d967481e324876e1f8cf4d3452148be228a4c3f2061bafe7efdfc4a8d5a94759464b9b5c619994d45dfcaf49e1a126f45bffff7f2000000000"), 8),
25 'R': deserialize_header(bfh("00000020552755b6c59f3d51e361d16281842a4e166007799665b5daed86a063dd89857415681cb2d00ff889193f6a68a93f5096aeb2d84ca0af6185a462555822552221a626f45bffff7f2000000000"), 9),
26 'S': deserialize_header(bfh("00000020a13a491cbefc93cd1bb1938f19957e22a134faf14c7dee951c45533e2c750f239dc087fc977b06c24a69c682d1afd1020e6dc1f087571ccec66310a786e1548fab26f45bffff7f2000000000"), 10),
27 'T': deserialize_header(bfh("00000020dbf3a9b55dfefbaf8b6e43a89cf833fa2e208bbc0c1c5d76c0d71b9e4a65337803b243756c25053253aeda309604363460a3911015929e68705bd89dff6fe064b026f45bffff7f2002000000"), 11),
28 'U': deserialize_header(bfh("000000203d0932b3b0c78eccb39a595a28ae4a7c966388648d7783fd1305ec8d40d4fe5fd67cb902a7d807cee7676cb543feec3e053aa824d5dfb528d5b94f9760313d9db726f45bffff7f2001000000"), 12),
29 'G': deserialize_header(bfh("00000020b833ed46eea01d4c980f59feee44a66aa1162748b6801029565d1466790c405c3a141ce635cbb1cd2b3a4fcdd0a3380517845ba41736c82a79cab535d31128066928f45bffff7f2001000000"), 6),
30 'H': deserialize_header(bfh("00000020e19e687f6e7f83ca394c114144dbbbc4f3f9c9450f66331a125413702a2e1a719690c2fe7c1a4450c74dc908fe94dd96c3b0637d51475e9e06a78e944a0c7fe26a28f45bffff7f2002000000"), 7),
31 'I': deserialize_header(bfh("0000002009dcb3b158293c89d7cf7ceeb513add122ebc3880a850f47afbb2747f5e48c54148be228a4c3f2061bafe7efdfc4a8d5a94759464b9b5c619994d45dfcaf49e16a28f45bffff7f2000000000"), 8),
32 'J': deserialize_header(bfh("000000206a65f3bdd3374a5a6c4538008ba0b0a560b8566291f9ef4280ab877627a1742815681cb2d00ff889193f6a68a93f5096aeb2d84ca0af6185a462555822552221c928f45bffff7f2000000000"), 9),
33 'K': deserialize_header(bfh("00000020bb3b421653548991998f96f8ba486b652fdb07ca16e9cee30ece033547cd1a6e9dc087fc977b06c24a69c682d1afd1020e6dc1f087571ccec66310a786e1548fca28f45bffff7f2000000000"), 10),
34 'L': deserialize_header(bfh("00000020c391d74d37c24a130f4bf4737932bdf9e206dd4fad22860ec5408978eb55d46303b243756c25053253aeda309604363460a3911015929e68705bd89dff6fe064ca28f45bffff7f2000000000"), 11),
35 'M': deserialize_header(bfh("000000206a65f3bdd3374a5a6c4538008ba0b0a560b8566291f9ef4280ab877627a1742815681cb2d00ff889193f6a68a93f5096aeb2d84ca0af6185a4625558225522214229f45bffff7f2000000000"), 9),
36 'N': deserialize_header(bfh("00000020383dab38b57f98aa9b4f0d5ff868bc674b4828d76766bf048296f4c45fff680a9dc087fc977b06c24a69c682d1afd1020e6dc1f087571ccec66310a786e1548f4329f45bffff7f2003000000"), 10),
37 'X': deserialize_header(bfh("0000002067f1857f54b7fef732cb4940f7d1b339472b3514660711a820330fd09d8fba6b03b243756c25053253aeda309604363460a3911015929e68705bd89dff6fe0649b29f45bffff7f2002000000"), 11),
38 'Y': deserialize_header(bfh("00000020db33c9768a9e5f7c37d0f09aad88d48165946c87d08f7d63793f07b5c08c527fd67cb902a7d807cee7676cb543feec3e053aa824d5dfb528d5b94f9760313d9d9b29f45bffff7f2000000000"), 12),
39 'Z': deserialize_header(bfh("0000002047822b67940e337fda38be6f13390b3596e4dea2549250256879722073824e7f0f2596c29203f8a0f71ae94193092dc8f113be3dbee4579f1e649fa3d6dcc38c622ef45bffff7f2003000000"), 13),
40 }
41 # tree of headers:
42 # - M <- N <- X <- Y <- Z
43 # /
44 # - G <- H <- I <- J <- K <- L
45 # /
46 # A <- B <- C <- D <- E <- F <- O <- P <- Q <- R <- S <- T <- U
47
48 @classmethod
49 def setUpClass(cls):
50 super().setUpClass()
51 constants.set_regtest()
52
53 @classmethod
54 def tearDownClass(cls):
55 super().tearDownClass()
56 constants.set_mainnet()
57
58 def setUp(self):
59 super().setUp()
60 self.data_dir = self.electrum_path
61 make_dir(os.path.join(self.data_dir, 'forks'))
62 self.config = SimpleConfig({'electrum_path': self.data_dir})
63 blockchain.blockchains = {}
64
65 def _append_header(self, chain: Blockchain, header: dict):
66 self.assertTrue(chain.can_connect(header))
67 chain.save_header(header)
68
69 def test_get_height_of_last_common_block_with_chain(self):
70 blockchain.blockchains[constants.net.GENESIS] = chain_u = Blockchain(
71 config=self.config, forkpoint=0, parent=None,
72 forkpoint_hash=constants.net.GENESIS, prev_hash=None)
73 open(chain_u.path(), 'w+').close()
74 self._append_header(chain_u, self.HEADERS['A'])
75 self._append_header(chain_u, self.HEADERS['B'])
76 self._append_header(chain_u, self.HEADERS['C'])
77 self._append_header(chain_u, self.HEADERS['D'])
78 self._append_header(chain_u, self.HEADERS['E'])
79 self._append_header(chain_u, self.HEADERS['F'])
80 self._append_header(chain_u, self.HEADERS['O'])
81 self._append_header(chain_u, self.HEADERS['P'])
82 self._append_header(chain_u, self.HEADERS['Q'])
83
84 chain_l = chain_u.fork(self.HEADERS['G'])
85 self._append_header(chain_l, self.HEADERS['H'])
86 self._append_header(chain_l, self.HEADERS['I'])
87 self._append_header(chain_l, self.HEADERS['J'])
88 self._append_header(chain_l, self.HEADERS['K'])
89 self._append_header(chain_l, self.HEADERS['L'])
90
91 self.assertEqual({chain_u: 8, chain_l: 5}, chain_u.get_parent_heights())
92 self.assertEqual({chain_l: 11}, chain_l.get_parent_heights())
93
94 chain_z = chain_l.fork(self.HEADERS['M'])
95 self._append_header(chain_z, self.HEADERS['N'])
96 self._append_header(chain_z, self.HEADERS['X'])
97 self._append_header(chain_z, self.HEADERS['Y'])
98 self._append_header(chain_z, self.HEADERS['Z'])
99
100 self.assertEqual({chain_u: 8, chain_z: 5}, chain_u.get_parent_heights())
101 self.assertEqual({chain_l: 11, chain_z: 8}, chain_l.get_parent_heights())
102 self.assertEqual({chain_z: 13}, chain_z.get_parent_heights())
103 self.assertEqual(5, chain_u.get_height_of_last_common_block_with_chain(chain_l))
104 self.assertEqual(5, chain_l.get_height_of_last_common_block_with_chain(chain_u))
105 self.assertEqual(5, chain_u.get_height_of_last_common_block_with_chain(chain_z))
106 self.assertEqual(5, chain_z.get_height_of_last_common_block_with_chain(chain_u))
107 self.assertEqual(8, chain_l.get_height_of_last_common_block_with_chain(chain_z))
108 self.assertEqual(8, chain_z.get_height_of_last_common_block_with_chain(chain_l))
109
110 self._append_header(chain_u, self.HEADERS['R'])
111 self._append_header(chain_u, self.HEADERS['S'])
112 self._append_header(chain_u, self.HEADERS['T'])
113 self._append_header(chain_u, self.HEADERS['U'])
114
115 self.assertEqual({chain_u: 12, chain_z: 5}, chain_u.get_parent_heights())
116 self.assertEqual({chain_l: 11, chain_z: 8}, chain_l.get_parent_heights())
117 self.assertEqual({chain_z: 13}, chain_z.get_parent_heights())
118 self.assertEqual(5, chain_u.get_height_of_last_common_block_with_chain(chain_l))
119 self.assertEqual(5, chain_l.get_height_of_last_common_block_with_chain(chain_u))
120 self.assertEqual(5, chain_u.get_height_of_last_common_block_with_chain(chain_z))
121 self.assertEqual(5, chain_z.get_height_of_last_common_block_with_chain(chain_u))
122 self.assertEqual(8, chain_l.get_height_of_last_common_block_with_chain(chain_z))
123 self.assertEqual(8, chain_z.get_height_of_last_common_block_with_chain(chain_l))
124
125 def test_parents_after_forking(self):
126 blockchain.blockchains[constants.net.GENESIS] = chain_u = Blockchain(
127 config=self.config, forkpoint=0, parent=None,
128 forkpoint_hash=constants.net.GENESIS, prev_hash=None)
129 open(chain_u.path(), 'w+').close()
130 self._append_header(chain_u, self.HEADERS['A'])
131 self._append_header(chain_u, self.HEADERS['B'])
132 self._append_header(chain_u, self.HEADERS['C'])
133 self._append_header(chain_u, self.HEADERS['D'])
134 self._append_header(chain_u, self.HEADERS['E'])
135 self._append_header(chain_u, self.HEADERS['F'])
136 self._append_header(chain_u, self.HEADERS['O'])
137 self._append_header(chain_u, self.HEADERS['P'])
138 self._append_header(chain_u, self.HEADERS['Q'])
139
140 self.assertEqual(None, chain_u.parent)
141
142 chain_l = chain_u.fork(self.HEADERS['G'])
143 self._append_header(chain_l, self.HEADERS['H'])
144 self._append_header(chain_l, self.HEADERS['I'])
145 self._append_header(chain_l, self.HEADERS['J'])
146 self._append_header(chain_l, self.HEADERS['K'])
147 self._append_header(chain_l, self.HEADERS['L'])
148
149 self.assertEqual(None, chain_l.parent)
150 self.assertEqual(chain_l, chain_u.parent)
151
152 chain_z = chain_l.fork(self.HEADERS['M'])
153 self._append_header(chain_z, self.HEADERS['N'])
154 self._append_header(chain_z, self.HEADERS['X'])
155 self._append_header(chain_z, self.HEADERS['Y'])
156 self._append_header(chain_z, self.HEADERS['Z'])
157
158 self.assertEqual(chain_z, chain_u.parent)
159 self.assertEqual(chain_z, chain_l.parent)
160 self.assertEqual(None, chain_z.parent)
161
162 self._append_header(chain_u, self.HEADERS['R'])
163 self._append_header(chain_u, self.HEADERS['S'])
164 self._append_header(chain_u, self.HEADERS['T'])
165 self._append_header(chain_u, self.HEADERS['U'])
166
167 self.assertEqual(chain_z, chain_u.parent)
168 self.assertEqual(chain_z, chain_l.parent)
169 self.assertEqual(None, chain_z.parent)
170
171 def test_forking_and_swapping(self):
172 blockchain.blockchains[constants.net.GENESIS] = chain_u = Blockchain(
173 config=self.config, forkpoint=0, parent=None,
174 forkpoint_hash=constants.net.GENESIS, prev_hash=None)
175 open(chain_u.path(), 'w+').close()
176
177 self._append_header(chain_u, self.HEADERS['A'])
178 self._append_header(chain_u, self.HEADERS['B'])
179 self._append_header(chain_u, self.HEADERS['C'])
180 self._append_header(chain_u, self.HEADERS['D'])
181 self._append_header(chain_u, self.HEADERS['E'])
182 self._append_header(chain_u, self.HEADERS['F'])
183 self._append_header(chain_u, self.HEADERS['O'])
184 self._append_header(chain_u, self.HEADERS['P'])
185 self._append_header(chain_u, self.HEADERS['Q'])
186 self._append_header(chain_u, self.HEADERS['R'])
187
188 chain_l = chain_u.fork(self.HEADERS['G'])
189 self._append_header(chain_l, self.HEADERS['H'])
190 self._append_header(chain_l, self.HEADERS['I'])
191 self._append_header(chain_l, self.HEADERS['J'])
192
193 # do checks
194 self.assertEqual(2, len(blockchain.blockchains))
195 self.assertEqual(1, len(os.listdir(os.path.join(self.data_dir, "forks"))))
196 self.assertEqual(0, chain_u.forkpoint)
197 self.assertEqual(None, chain_u.parent)
198 self.assertEqual(constants.net.GENESIS, chain_u._forkpoint_hash)
199 self.assertEqual(None, chain_u._prev_hash)
200 self.assertEqual(os.path.join(self.data_dir, "blockchain_headers"), chain_u.path())
201 self.assertEqual(10 * 80, os.stat(chain_u.path()).st_size)
202 self.assertEqual(6, chain_l.forkpoint)
203 self.assertEqual(chain_u, chain_l.parent)
204 self.assertEqual(hash_header(self.HEADERS['G']), chain_l._forkpoint_hash)
205 self.assertEqual(hash_header(self.HEADERS['F']), chain_l._prev_hash)
206 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_6_5c400c7966145d56291080b6482716a16aa644eefe590f984c1da0ee46ed33b8_711a2e2a701354121a33660f45c9f9f3c4bbdb4441114c39ca837f6e7f689ee1"), chain_l.path())
207 self.assertEqual(4 * 80, os.stat(chain_l.path()).st_size)
208
209 self._append_header(chain_l, self.HEADERS['K'])
210
211 # chains were swapped, do checks
212 self.assertEqual(2, len(blockchain.blockchains))
213 self.assertEqual(1, len(os.listdir(os.path.join(self.data_dir, "forks"))))
214 self.assertEqual(6, chain_u.forkpoint)
215 self.assertEqual(chain_l, chain_u.parent)
216 self.assertEqual(hash_header(self.HEADERS['O']), chain_u._forkpoint_hash)
217 self.assertEqual(hash_header(self.HEADERS['F']), chain_u._prev_hash)
218 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_6_5c400c7966145d56291080b6482716a16aa644eefe590f984c1da0ee46ed33b8_aff81830e28e01ef7d23277c56779a6b93f251a2d50dcc09d7c87d119e1e8ab"), chain_u.path())
219 self.assertEqual(4 * 80, os.stat(chain_u.path()).st_size)
220 self.assertEqual(0, chain_l.forkpoint)
221 self.assertEqual(None, chain_l.parent)
222 self.assertEqual(constants.net.GENESIS, chain_l._forkpoint_hash)
223 self.assertEqual(None, chain_l._prev_hash)
224 self.assertEqual(os.path.join(self.data_dir, "blockchain_headers"), chain_l.path())
225 self.assertEqual(11 * 80, os.stat(chain_l.path()).st_size)
226 for b in (chain_u, chain_l):
227 self.assertTrue(all([b.can_connect(b.read_header(i), False) for i in range(b.height())]))
228
229 self._append_header(chain_u, self.HEADERS['S'])
230 self._append_header(chain_u, self.HEADERS['T'])
231 self._append_header(chain_u, self.HEADERS['U'])
232 self._append_header(chain_l, self.HEADERS['L'])
233
234 chain_z = chain_l.fork(self.HEADERS['M'])
235 self._append_header(chain_z, self.HEADERS['N'])
236 self._append_header(chain_z, self.HEADERS['X'])
237 self._append_header(chain_z, self.HEADERS['Y'])
238 self._append_header(chain_z, self.HEADERS['Z'])
239
240 # chain_z became best chain, do checks
241 self.assertEqual(3, len(blockchain.blockchains))
242 self.assertEqual(2, len(os.listdir(os.path.join(self.data_dir, "forks"))))
243 self.assertEqual(0, chain_z.forkpoint)
244 self.assertEqual(None, chain_z.parent)
245 self.assertEqual(constants.net.GENESIS, chain_z._forkpoint_hash)
246 self.assertEqual(None, chain_z._prev_hash)
247 self.assertEqual(os.path.join(self.data_dir, "blockchain_headers"), chain_z.path())
248 self.assertEqual(14 * 80, os.stat(chain_z.path()).st_size)
249 self.assertEqual(9, chain_l.forkpoint)
250 self.assertEqual(chain_z, chain_l.parent)
251 self.assertEqual(hash_header(self.HEADERS['J']), chain_l._forkpoint_hash)
252 self.assertEqual(hash_header(self.HEADERS['I']), chain_l._prev_hash)
253 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_9_2874a1277687ab8042eff9916256b860a5b0a08b0038456c5a4a37d3bdf3656a_6e1acd473503ce0ee3cee916ca07db2f656b48baf8968f999189545316423bbb"), chain_l.path())
254 self.assertEqual(3 * 80, os.stat(chain_l.path()).st_size)
255 self.assertEqual(6, chain_u.forkpoint)
256 self.assertEqual(chain_z, chain_u.parent)
257 self.assertEqual(hash_header(self.HEADERS['O']), chain_u._forkpoint_hash)
258 self.assertEqual(hash_header(self.HEADERS['F']), chain_u._prev_hash)
259 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_6_5c400c7966145d56291080b6482716a16aa644eefe590f984c1da0ee46ed33b8_aff81830e28e01ef7d23277c56779a6b93f251a2d50dcc09d7c87d119e1e8ab"), chain_u.path())
260 self.assertEqual(7 * 80, os.stat(chain_u.path()).st_size)
261 for b in (chain_u, chain_l, chain_z):
262 self.assertTrue(all([b.can_connect(b.read_header(i), False) for i in range(b.height())]))
263
264 self.assertEqual(constants.net.GENESIS, chain_z.get_hash(0))
265 self.assertEqual(hash_header(self.HEADERS['F']), chain_z.get_hash(5))
266 self.assertEqual(hash_header(self.HEADERS['G']), chain_z.get_hash(6))
267 self.assertEqual(hash_header(self.HEADERS['I']), chain_z.get_hash(8))
268 self.assertEqual(hash_header(self.HEADERS['M']), chain_z.get_hash(9))
269 self.assertEqual(hash_header(self.HEADERS['Z']), chain_z.get_hash(13))
270
271 def test_doing_multiple_swaps_after_single_new_header(self):
272 blockchain.blockchains[constants.net.GENESIS] = chain_u = Blockchain(
273 config=self.config, forkpoint=0, parent=None,
274 forkpoint_hash=constants.net.GENESIS, prev_hash=None)
275 open(chain_u.path(), 'w+').close()
276
277 self._append_header(chain_u, self.HEADERS['A'])
278 self._append_header(chain_u, self.HEADERS['B'])
279 self._append_header(chain_u, self.HEADERS['C'])
280 self._append_header(chain_u, self.HEADERS['D'])
281 self._append_header(chain_u, self.HEADERS['E'])
282 self._append_header(chain_u, self.HEADERS['F'])
283 self._append_header(chain_u, self.HEADERS['O'])
284 self._append_header(chain_u, self.HEADERS['P'])
285 self._append_header(chain_u, self.HEADERS['Q'])
286 self._append_header(chain_u, self.HEADERS['R'])
287 self._append_header(chain_u, self.HEADERS['S'])
288
289 self.assertEqual(1, len(blockchain.blockchains))
290 self.assertEqual(0, len(os.listdir(os.path.join(self.data_dir, "forks"))))
291
292 chain_l = chain_u.fork(self.HEADERS['G'])
293 self._append_header(chain_l, self.HEADERS['H'])
294 self._append_header(chain_l, self.HEADERS['I'])
295 self._append_header(chain_l, self.HEADERS['J'])
296 self._append_header(chain_l, self.HEADERS['K'])
297 # now chain_u is best chain, but it's tied with chain_l
298
299 self.assertEqual(2, len(blockchain.blockchains))
300 self.assertEqual(1, len(os.listdir(os.path.join(self.data_dir, "forks"))))
301
302 chain_z = chain_l.fork(self.HEADERS['M'])
303 self._append_header(chain_z, self.HEADERS['N'])
304 self._append_header(chain_z, self.HEADERS['X'])
305
306 self.assertEqual(3, len(blockchain.blockchains))
307 self.assertEqual(2, len(os.listdir(os.path.join(self.data_dir, "forks"))))
308
309 # chain_z became best chain, do checks
310 self.assertEqual(0, chain_z.forkpoint)
311 self.assertEqual(None, chain_z.parent)
312 self.assertEqual(constants.net.GENESIS, chain_z._forkpoint_hash)
313 self.assertEqual(None, chain_z._prev_hash)
314 self.assertEqual(os.path.join(self.data_dir, "blockchain_headers"), chain_z.path())
315 self.assertEqual(12 * 80, os.stat(chain_z.path()).st_size)
316 self.assertEqual(9, chain_l.forkpoint)
317 self.assertEqual(chain_z, chain_l.parent)
318 self.assertEqual(hash_header(self.HEADERS['J']), chain_l._forkpoint_hash)
319 self.assertEqual(hash_header(self.HEADERS['I']), chain_l._prev_hash)
320 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_9_2874a1277687ab8042eff9916256b860a5b0a08b0038456c5a4a37d3bdf3656a_6e1acd473503ce0ee3cee916ca07db2f656b48baf8968f999189545316423bbb"), chain_l.path())
321 self.assertEqual(2 * 80, os.stat(chain_l.path()).st_size)
322 self.assertEqual(6, chain_u.forkpoint)
323 self.assertEqual(chain_z, chain_u.parent)
324 self.assertEqual(hash_header(self.HEADERS['O']), chain_u._forkpoint_hash)
325 self.assertEqual(hash_header(self.HEADERS['F']), chain_u._prev_hash)
326 self.assertEqual(os.path.join(self.data_dir, "forks", "fork2_6_5c400c7966145d56291080b6482716a16aa644eefe590f984c1da0ee46ed33b8_aff81830e28e01ef7d23277c56779a6b93f251a2d50dcc09d7c87d119e1e8ab"), chain_u.path())
327 self.assertEqual(5 * 80, os.stat(chain_u.path()).st_size)
328
329 self.assertEqual(constants.net.GENESIS, chain_z.get_hash(0))
330 self.assertEqual(hash_header(self.HEADERS['F']), chain_z.get_hash(5))
331 self.assertEqual(hash_header(self.HEADERS['G']), chain_z.get_hash(6))
332 self.assertEqual(hash_header(self.HEADERS['I']), chain_z.get_hash(8))
333 self.assertEqual(hash_header(self.HEADERS['M']), chain_z.get_hash(9))
334 self.assertEqual(hash_header(self.HEADERS['X']), chain_z.get_hash(11))
335
336 for b in (chain_u, chain_l, chain_z):
337 self.assertTrue(all([b.can_connect(b.read_header(i), False) for i in range(b.height())]))
338
339 def get_chains_that_contain_header_helper(self, header: dict):
340 height = header['block_height']
341 header_hash = hash_header(header)
342 return blockchain.get_chains_that_contain_header(height, header_hash)
343
344 def test_get_chains_that_contain_header(self):
345 blockchain.blockchains[constants.net.GENESIS] = chain_u = Blockchain(
346 config=self.config, forkpoint=0, parent=None,
347 forkpoint_hash=constants.net.GENESIS, prev_hash=None)
348 open(chain_u.path(), 'w+').close()
349 self._append_header(chain_u, self.HEADERS['A'])
350 self._append_header(chain_u, self.HEADERS['B'])
351 self._append_header(chain_u, self.HEADERS['C'])
352 self._append_header(chain_u, self.HEADERS['D'])
353 self._append_header(chain_u, self.HEADERS['E'])
354 self._append_header(chain_u, self.HEADERS['F'])
355 self._append_header(chain_u, self.HEADERS['O'])
356 self._append_header(chain_u, self.HEADERS['P'])
357 self._append_header(chain_u, self.HEADERS['Q'])
358
359 chain_l = chain_u.fork(self.HEADERS['G'])
360 self._append_header(chain_l, self.HEADERS['H'])
361 self._append_header(chain_l, self.HEADERS['I'])
362 self._append_header(chain_l, self.HEADERS['J'])
363 self._append_header(chain_l, self.HEADERS['K'])
364 self._append_header(chain_l, self.HEADERS['L'])
365
366 chain_z = chain_l.fork(self.HEADERS['M'])
367
368 self.assertEqual([chain_l, chain_z, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['A']))
369 self.assertEqual([chain_l, chain_z, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['C']))
370 self.assertEqual([chain_l, chain_z, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['F']))
371 self.assertEqual([chain_l, chain_z], self.get_chains_that_contain_header_helper(self.HEADERS['G']))
372 self.assertEqual([chain_l, chain_z], self.get_chains_that_contain_header_helper(self.HEADERS['I']))
373 self.assertEqual([chain_z], self.get_chains_that_contain_header_helper(self.HEADERS['M']))
374 self.assertEqual([chain_l], self.get_chains_that_contain_header_helper(self.HEADERS['K']))
375
376 self._append_header(chain_z, self.HEADERS['N'])
377 self._append_header(chain_z, self.HEADERS['X'])
378 self._append_header(chain_z, self.HEADERS['Y'])
379 self._append_header(chain_z, self.HEADERS['Z'])
380
381 self.assertEqual([chain_z, chain_l, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['A']))
382 self.assertEqual([chain_z, chain_l, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['C']))
383 self.assertEqual([chain_z, chain_l, chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['F']))
384 self.assertEqual([chain_u], self.get_chains_that_contain_header_helper(self.HEADERS['O']))
385 self.assertEqual([chain_z, chain_l], self.get_chains_that_contain_header_helper(self.HEADERS['I']))
386
387
388 class TestVerifyHeader(ElectrumTestCase):
389
390 # Data for Bitcoin block header #100.
391 valid_header = "0100000095194b8567fe2e8bbda931afd01a7acd399b9325cb54683e64129bcd00000000660802c98f18fd34fd16d61c63cf447568370124ac5f3be626c2e1c3c9f0052d19a76949ffff001d33f3c25d"
392 target = Blockchain.bits_to_target(0x1d00ffff)
393 prev_hash = "00000000cd9b12643e6854cb25939b39cd7a1ad0af31a9bd8b2efe67854b1995"
394
395 def setUp(self):
396 super().setUp()
397 self.header = deserialize_header(bfh(self.valid_header), 100)
398
399 def test_valid_header(self):
400 Blockchain.verify_header(self.header, self.prev_hash, self.target)
401
402 def test_expected_hash_mismatch(self):
403 with self.assertRaises(Exception):
404 Blockchain.verify_header(self.header, self.prev_hash, self.target,
405 expected_header_hash="foo")
406
407 def test_prev_hash_mismatch(self):
408 with self.assertRaises(Exception):
409 Blockchain.verify_header(self.header, "foo", self.target)
410
411 def test_target_mismatch(self):
412 with self.assertRaises(Exception):
413 other_target = Blockchain.bits_to_target(0x1d00eeee)
414 Blockchain.verify_header(self.header, self.prev_hash, other_target)
415
416 def test_insufficient_pow(self):
417 with self.assertRaises(Exception):
418 self.header["nonce"] = 42
419 Blockchain.verify_header(self.header, self.prev_hash, self.target)