Inside Bitcoin

251        if self.nodes[2].getblockcount() < self.mainchainheight:
252            blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
253            self.log.info(f"Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: {blocks_to_mine}")
254            self.nodes[0].invalidateblock(block_hash_1295)
255            assert_equal(self.nodes[0].getblockcount(), self.mainchainheight)
256            assert_equal(self.nodes[0].getbestblockhash(), self.mainchainhash2)
257            goalbesthash = self.generate(self.nodes[0], blocks_to_mine, sync_fun=self.no_op)[-1]
258            goalbestheight = first_reorg_height + 1
259
260        self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
261        # Wait for Node 2 to reorg to proper height
262        self.wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900)
263        assert_equal(self.nodes[2].getbestblockhash(), goalbesthash)
264        # Verify we can now have the data for a block previously pruned
265        assert_equal(self.nodes[2].getblock(self.forkhash)["height"], self.forkheight)
266
267    def manual_test(self, node_number, use_timestamp):
268        # at this point, node has 995 blocks and has not yet run in prune mode
269        self.start_node(node_number)
270        node = self.nodes[node_number]
271        assert_equal(node.getblockcount(), 995)
272        assert_raises_rpc_error(-1, "Cannot prune blocks because node is not in prune mode", node.pruneblockchain, 500)
273
274        # now re-start in manual pruning mode
275        self.restart_node(node_number, extra_args=["-prune=1"])
276        node = self.nodes[node_number]
277        assert_equal(node.getblockcount(), 995)
278
279        def height(index):
280            if use_timestamp:
281                return node.getblockheader(node.getblockhash(index))["time"] + TIMESTAMP_WINDOW
282            else:
283                return index
284
285        def prune(index):
286            ret = node.pruneblockchain(height=height(index))
287            assert_equal(ret + 1, node.getblockchaininfo()['pruneheight'])
288
289        def has_block(index):
290            return os.path.isfile(os.path.join(self.nodes[node_number].blocks_path, f"blk{index:05}.dat"))
291
292        # should not prune because chain tip of node 3 (995) < PruneAfterHeight (1000)
293        assert_raises_rpc_error(-1, "Blockchain is too short for pruning", node.pruneblockchain, height(500))
294
295        # Save block transaction count before pruning, assert value
296        block1_details = node.getblock(node.getblockhash(1))
297        assert_equal(block1_details["nTx"], len(block1_details["tx"]))
298
299        # mine 6 blocks so we are at height 1001 (i.e., above PruneAfterHeight)
300        self.generate(node, 6, sync_fun=self.no_op)
301        assert_equal(node.getblockchaininfo()["blocks"], 1001)
302
303        # prune parameter in the future (block or timestamp) should raise an exception
304        future_parameter = height(1001) + 5
305        if use_timestamp:
306            assert_raises_rpc_error(-8, "Could not find block with at least the specified timestamp", node.pruneblockchain, future_parameter)
307        else:
308            assert_raises_rpc_error(-8, "Blockchain is shorter than the attempted prune height", node.pruneblockchain, future_parameter)
309
310        # Pruned block should still know the number of transactions
311        assert_equal(node.getblockheader(node.getblockhash(1))["nTx"], block1_details["nTx"])
312
313        # negative heights should raise an exception
314        assert_raises_rpc_error(-8, "Negative block height", node.pruneblockchain, -10)
315
316        # height=100 too low to prune first block file so this is a no-op
317        prune(100)
318        assert has_block(0), "blk00000.dat is missing when should still be there"
319
320        # Does nothing
321        node.pruneblockchain(height(0))
322        assert has_block(0), "blk00000.dat is missing when should still be there"
323
324        # height=500 should prune first file
325        prune(500)
326        assert not has_block(0), "blk00000.dat is still there, should be pruned by now"
327        assert has_block(1), "blk00001.dat is missing when should still be there"
328
329        # height=650 should prune second file
330        prune(650)
331        assert not has_block(1), "blk00001.dat is still there, should be pruned by now"
332
333        # height=1000 should not prune anything more, because tip-288 is in blk00002.dat.
334        prune(1000)
335        assert has_block(2), "blk00002.dat is still there, should be pruned by now"
336
337        # advance the tip so blk00002.dat and blk00003.dat can be pruned (the last 288 blocks should now be in blk00004.dat)
338        self.generate(node, MIN_BLOCKS_TO_KEEP, sync_fun=self.no_op)
339        prune(1000)
340        assert not has_block(2), "blk00002.dat is still there, should be pruned by now"
341        assert not has_block(3), "blk00003.dat is still there, should be pruned by now"
342
343        # stop node, start back up with auto-prune at 550 MiB, make sure still runs
344        self.restart_node(node_number, extra_args=["-prune=550"])
345
346        self.log.info("Success")
347
348    def test_wallet_rescan(self):
349        # check that the pruning node's wallet is still in good shape
350        self.log.info("Stop and start pruning node to trigger wallet rescan")
351        self.restart_node(2, extra_args=["-prune=550"])
352
353        self.wait_until(lambda: self.nodes[2].getwalletinfo()["scanning"] is False)
354        self.wait_until(lambda: self.nodes[2].getwalletinfo()["lastprocessedblock"]["height"] == self.nodes[2].getblockcount())
355
356        # check that wallet loads successfully when restarting a pruned node after IBD.
357        # this was reported to fail in #7494.
358        self.restart_node(5, extra_args=["-prune=550", "-blockfilterindex=1"]) # restart to trigger rescan
359
360        self.wait_until(lambda: self.nodes[5].getwalletinfo()["scanning"] is False)
361        self.wait_until(lambda: self.nodes[5].getwalletinfo()["lastprocessedblock"]["height"] == self.nodes[0].getblockcount())
362
363    def run_test(self):
364        self.log.info("Warning! This test requires 4GB of disk space")
365
366        self.log.info("Mining a big blockchain of 995 blocks")
367        self.create_big_chain()
368        # Chain diagram key:
369        # *   blocks on main chain
370        # +,&,$,@ blocks on other forks
371        # X   invalidated block
372        # N1  Node 1
373        #
374        # Start by mining a simple chain that all nodes have
375        # N0=N1=N2 **...*(995)
376
377        # stop manual-pruning node with 995 blocks
378        self.stop_node(3)
379        self.stop_node(4)
380
381        self.log.info("Check that we haven't started pruning yet because we're below PruneAfterHeight")
382        self.test_height_min()
383        # Extend this chain past the PruneAfterHeight
384        # N0=N1=N2 **...*(1020)
385
386        self.log.info("Check that we'll exceed disk space target if we have a very high stale block rate")
387        self.create_chain_with_staleblocks()
388        # Disconnect N0
389        # And mine a 24 block chain on N1 and a separate 25 block chain on N0
390        # N1=N2 **...*+...+(1044)
391        # N0    **...**...**(1045)
392        #
393        # reconnect nodes causing reorg on N1 and N2
394        # N1=N2 **...*(1020) *...**(1045)
395        #                   \
396        #                    +...+(1044)
397        #
398        # repeat this process until you have 12 stale forks hanging off the
399        # main chain on N1 and N2
400        # N0    *************************...***************************(1320)
401        #
402        # N1=N2 **...*(1020) *...**(1045) *..         ..**(1295) *...**(1320)
403        #                   \            \                      \
404        #                    +...+(1044)  &..                    $...$(1319)
405
406        # Save some current chain state for later use
407        self.mainchainheight = self.nodes[2].getblockcount()  # 1320
408        self.mainchainhash2 = self.nodes[2].getblockhash(self.mainchainheight)
409
410        self.log.info("Check that we can survive a 288 block reorg still")
411        self.reorg_test()  # (1033, )
412        # Now create a 288 block reorg by mining a longer chain on N1
413        # First disconnect N1
414        # Then invalidate 1033 on main chain and 1032 on fork so height is 1032 on main chain
415        # N1   **...*(1020) **...**(1032)X..
416        #                  \
417        #                   ++...+(1031)X..
418        #
419        # Now mine 300 more blocks on N1
420        # N1    **...*(1020) **...**(1032) @@...@(1332)
421        #                 \               \
422        #                  \               X...
423        #                   \                 \
424        #                    ++...+(1031)X..   ..
425        #
426        # Reconnect nodes and mine 220 more blocks on N1
427        # N1    **...*(1020) **...**(1032) @@...@@@(1552)
428        #                 \               \
429        #                  \               X...
430        #                   \                 \
431        #                    ++...+(1031)X..   ..
432        #
433        # N2    **...*(1020) **...**(1032) @@...@@@(1552)
434        #                 \               \
435        #                  \               *...**(1320)
436        #                   \                 \
437        #                    ++...++(1044)     ..
438        #
439        # N0    ********************(1032) @@...@@@(1552)
440        #                                 \
441        #                                  *...**(1320)
442
443        self.log.info("Test that we can rerequest a block we previously pruned if needed for a reorg")
444        self.reorg_back()
445        # Verify that N2 still has block 1033 on current chain (@), but not on main chain (*)
446        # Invalidate 1033 on current chain (@) on N2 and we should be able to reorg to
447        # original main chain (*), but will require redownload of some blocks
448        # In order to have a peer we think we can download from, must also perform this invalidation
449        # on N0 and mine a new longest chain to trigger.
450        # Final result:
451        # N0    ********************(1032) **...****(1553)
452        #                                 \
453        #                                  X@...@@@(1552)
454        #
455        # N2    **...*(1020) **...**(1032) **...****(1553)
456        #                 \               \
457        #                  \               X@...@@@(1552)
458        #                   \
459        #                    +..
460        #
461        # N1 doesn't change because 1033 on main chain (*) is invalid
462
463        self.log.info("Test manual pruning with block indices")
464        self.manual_test(3, use_timestamp=False)
465
466        self.log.info("Test manual pruning with timestamps")
467        self.manual_test(4, use_timestamp=True)
468
469        self.log.info("Syncing node 5 to node 0")
470        self.connect_nodes(0, 5)
471        self.sync_blocks([self.nodes[0], self.nodes[5]], wait=5, timeout=300)
472
473        self.log.info("Test prune with a new index")
474        self.restart_node(0, extra_args=["-prune=550", "-blockfilterindex=1"])
475        node = self.nodes[0]
476        self.wait_until(lambda: node.getindexinfo()["basic block filter index"]["best_block_height"] >= 10, timeout=300)
477
478        if self.is_wallet_compiled():
479            self.log.info("Test wallet re-scan")
480            self.test_wallet_rescan()
481
482            self.log.info("Test it's not possible to rescan beyond pruned data")
483            self.test_rescan_blockchain()
484
485        self.log.info("Test invalid pruning command line options")
486        self.test_invalid_command_line_options()
487
488        self.log.info("Test scanblocks can not return pruned data")
489        self.test_scanblocks_pruned()
490
491        self.log.info("Test pruneheight reflects the presence of block and undo data")
492        self.test_pruneheight_undo_presence()
493
494        self.log.info("Done")
495
496    def test_scanblocks_pruned(self):
497        node = self.nodes[5]
498        genesis_blockhash = node.getblockhash(0)
499        false_positive_spk = bytes.fromhex("001400000000000000000000000000000000000cadcb")
500