Inside Bitcoin

501            dump_output4['txoutset_hash'],
502            "147d1789e3e29a62e3e15b80078b50603afb5e1e70ea07001c94666afbde38df")
503        assert_not_equal(sha256sum_file(dump_output['path']), sha256sum_file(dump_output4['path']))
504
505        # Use a hash instead of a height
506        prev_snap_hash = n0.getblockhash(prev_snap_height)
507        dump_output5 = n0.dumptxoutset('utxos5.dat', rollback=prev_snap_hash)
508        assert_equal(sha256sum_file(dump_output4['path']), sha256sum_file(dump_output5['path']))
509
510        # Ensure n0 is back at the tip
511        assert_equal(n0.getblockchaininfo()["blocks"], FINAL_HEIGHT)
512
513        self.test_snapshot_with_less_work(dump_output['path'])
514        self.test_invalid_mempool_state(dump_output['path'])
515        self.test_invalid_snapshot_scenarios(dump_output['path'])
516        self.test_invalid_chainstate_scenarios()
517        self.test_invalid_file_path()
518        self.test_snapshot_block_invalidated(dump_output['path'])
519        self.test_snapshot_not_on_most_work_chain(dump_output['path'])
520
521        # Prune-node sanity check
522        assert 'NETWORK' not in n1.getnetworkinfo()['localservicesnames']
523
524        self.log.info(f"Loading snapshot into second node from {dump_output['path']}")
525        # This node's tip is on an ancestor block of the snapshot, which should
526        # be the normal case
527        loaded = n1.loadtxoutset(dump_output['path'])
528        assert_equal(loaded['coins_loaded'], SNAPSHOT_BASE_HEIGHT)
529        assert_equal(loaded['base_height'], SNAPSHOT_BASE_HEIGHT)
530
531        self.log.info("Confirm that local services remain unchanged")
532        # Since n1 is a pruned node, the 'NETWORK' service flag must always be unset.
533        self.assert_only_network_limited_service(n1)
534
535        self.log.info("Check that UTXO-querying RPCs operate on snapshot chainstate")
536        snapshot_hash = loaded['tip_hash']
537        snapshot_num_coins = loaded['coins_loaded']
538        # coinstatsindex might be not caught up yet and is not relevant for this test, so don't use it
539        utxo_info = n1.gettxoutsetinfo(use_index=False)
540        assert_equal(utxo_info['txouts'], snapshot_num_coins)
541        assert_equal(utxo_info['height'], SNAPSHOT_BASE_HEIGHT)
542        assert_equal(utxo_info['bestblock'], snapshot_hash)
543
544        self.log.info("Check that getblockchaininfo returns information about the background validation process")
545        expected_keys = [
546            "snapshotheight",
547            "blocks",
548            "bestblockhash",
549            "mediantime",
550            "chainwork",
551            "verificationprogress"
552        ]
553        res = n1.getblockchaininfo()
554        assert "backgroundvalidation" in res.keys()
555        bv_res = res["backgroundvalidation"]
556        assert_equal(sorted(expected_keys), sorted(bv_res.keys()))
557        assert_equal(bv_res["snapshotheight"], SNAPSHOT_BASE_HEIGHT)
558        assert_equal(bv_res["blocks"], START_HEIGHT)
559        assert_equal(bv_res["bestblockhash"], n1.getblockhash(START_HEIGHT))
560        block = n1.getblockheader(bv_res["bestblockhash"])
561        assert_equal(bv_res["mediantime"], block["mediantime"])
562        assert_equal(bv_res["chainwork"], block["chainwork"])
563        background_tx_count = n1.getchaintxstats(blockhash=bv_res["bestblockhash"])["txcount"]
564        snapshot_tx_count = n1.getchaintxstats(blockhash=snapshot_hash)["txcount"]
565        expected_verification_progress = background_tx_count / snapshot_tx_count
566        assert_approx(bv_res["verificationprogress"], expected_verification_progress, vspan=0.01)
567
568        # find coinbase output at snapshot height on node0 and scan for it on node1,
569        # where the block is not available, but the snapshot was loaded successfully
570        coinbase_tx = n0.getblock(snapshot_hash, verbosity=2)['tx'][0]
571        assert_raises_rpc_error(-1, "Block not available (not fully downloaded)", n1.getblock, snapshot_hash)
572        coinbase_output_descriptor = coinbase_tx['vout'][0]['scriptPubKey']['desc']
573        scan_result = n1.scantxoutset('start', [coinbase_output_descriptor])
574        assert_equal(scan_result['success'], True)
575        assert_equal(scan_result['txouts'], snapshot_num_coins)
576        assert_equal(scan_result['height'], SNAPSHOT_BASE_HEIGHT)
577        assert_equal(scan_result['bestblock'], snapshot_hash)
578        scan_utxos = [(coin['txid'], coin['vout']) for coin in scan_result['unspents']]
579        assert (coinbase_tx['txid'], 0) in scan_utxos
580
581        txout_result = n1.gettxout(coinbase_tx['txid'], 0)
582        assert_equal(txout_result['scriptPubKey']['desc'], coinbase_output_descriptor)
583
584        def check_tx_counts(final: bool) -> None:
585            """Check nTx and nChainTx intermediate values right after loading
586            the snapshot, and final values after the snapshot is validated."""
587            for height, block in blocks.items():
588                tx = n1.getblockheader(block.hash)["nTx"]
589                stats = n1.getchaintxstats(nblocks=1, blockhash=block.hash)
590                chain_tx = stats.get("txcount", None)
591                window_tx_count = stats.get("window_tx_count", None)
592                tx_rate = stats.get("txrate", None)
593                window_interval = stats.get("window_interval")
594
595                # Intermediate nTx of the starting block should be set, but nTx of
596                # later blocks should be 0 before they are downloaded.
597                # The window_tx_count of one block is equal to the blocks tx count.
598                # If the window tx count is unknown, the value is missing.
599                # The tx_rate is calculated from window_tx_count and window_interval
600                # when possible.
601                if final or height == START_HEIGHT:
602                    assert_equal(tx, block.tx)
603                    assert_equal(window_tx_count, tx)
604                    if window_interval > 0:
605                        assert_approx(tx_rate, window_tx_count / window_interval, vspan=0.1)
606                    else:
607                        assert_equal(tx_rate, None)
608                else:
609                    assert_equal(tx, 0)
610                    assert_equal(window_tx_count, None)
611
612                # Intermediate nChainTx of the starting block and snapshot block
613                # should be set, but others should be None until they are downloaded.
614                if final or height in (START_HEIGHT, SNAPSHOT_BASE_HEIGHT):
615                    assert_equal(chain_tx, block.chain_tx)
616                else:
617                    assert_equal(chain_tx, None)
618
619        check_tx_counts(final=False)
620
621        normal, snapshot = n1.getchainstates()["chainstates"]
622        assert_equal(normal['blocks'], START_HEIGHT)
623        assert_equal(normal.get('snapshot_blockhash'), None)
624        assert_equal(normal['validated'], True)
625        assert_equal(snapshot['blocks'], SNAPSHOT_BASE_HEIGHT)
626        assert_equal(snapshot['snapshot_blockhash'], dump_output['base_hash'])
627        assert_equal(snapshot['validated'], False)
628
629        assert_equal(n1.getblockchaininfo()["blocks"], SNAPSHOT_BASE_HEIGHT)
630
631        self.log.info("Submit a stale block that forked off the chain before the snapshot")
632        # Normally a block like this would not be downloaded, but if it is
633        # submitted early before the background chain catches up to the fork
634        # point, it winds up in m_blocks_unlinked and triggers a corner case
635        # that previously crashed CheckBlockIndex.
636        n1.submitblock(stale_block)
637        n1.getchaintips()
638        n1.getblock(stale_hash)
639
640        self.log.info("Submit a spending transaction for a snapshot chainstate coin to the mempool")
641        # spend the coinbase output of the first block that is not available on node1
642        spend_coin_blockhash = n1.getblockhash(START_HEIGHT + 1)
643        assert_raises_rpc_error(-1, "Block not available (not fully downloaded)", n1.getblock, spend_coin_blockhash)
644        prev_tx = n0.getblock(spend_coin_blockhash, 3)['tx'][0]
645        prevout = {"txid": prev_tx['txid'], "vout": 0, "scriptPubKey": prev_tx['vout'][0]['scriptPubKey']['hex']}
646        privkey = n0.get_deterministic_priv_key().key
647        raw_tx = n1.createrawtransaction([prevout], {getnewdestination()[2]: 24.99})
648        signed_tx = n1.signrawtransactionwithkey(raw_tx, [privkey], [prevout])['hex']
649        signed_txid = tx_from_hex(signed_tx).txid_hex
650
651        assert n1.gettxout(prev_tx['txid'], 0) is not None
652        n1.sendrawtransaction(signed_tx)
653        assert signed_txid in n1.getrawmempool()
654        assert not n1.gettxout(prev_tx['txid'], 0)
655
656        PAUSE_HEIGHT = FINAL_HEIGHT - 40
657
658        self.log.info(f"Sync node up to height {PAUSE_HEIGHT}")
659        # During snapshot tip sync, the node must remain in 'limited' mode.
660        self.assert_only_network_limited_service(n1)
661        dumb_sync_blocks(src=n0, dst=n1, height=PAUSE_HEIGHT)
662
663        self.log.info("Checking that blocks are segmented on disk")
664        assert self.has_blockfile(n1, "00000"), "normal blockfile missing"
665        assert self.has_blockfile(n1, "00001"), "assumed blockfile missing"
666        assert not self.has_blockfile(n1, "00002"), "too many blockfiles"
667
668        # The node must remain in 'limited' mode
669        self.assert_only_network_limited_service(n1)
670
671        # Send snapshot block to n1 out of order. This makes the test less
672        # realistic because normally the snapshot block is one of the last
673        # blocks downloaded, but its useful to test because it triggers more
674        # corner cases in ReceivedBlockTransactions() and CheckBlockIndex()
675        # setting and testing nChainTx values, and it exposed previous bugs.
676        snapshot_hash = n0.getblockhash(SNAPSHOT_BASE_HEIGHT)
677        snapshot_block = n0.getblock(snapshot_hash, 0)
678        n1.submitblock(snapshot_block)
679
680        self.connect_nodes(0, 1)
681
682        self.log.info(f"Ensuring snapshot chain syncs to tip. ({FINAL_HEIGHT})")
683        self.wait_until(lambda: n1.getchainstates()['chainstates'][-1]['blocks'] == FINAL_HEIGHT)
684        self.sync_blocks(nodes=(n0, n1))
685
686        self.log.info("Ensuring background validation completes")
687        self.wait_until(lambda: len(n1.getchainstates()['chainstates']) == 1)
688
689        # Since n1 is a pruned node, it will not signal NODE_NETWORK after
690        # completing the background sync.
691        self.assert_only_network_limited_service(n1)
692
693        # Ensure indexes have synced.
694        completed_idx_state = {
695            'basic block filter index': COMPLETE_IDX,
696            'coinstatsindex': COMPLETE_IDX,
697        }
698        self.wait_until(lambda: n1.getindexinfo() == completed_idx_state)
699
700        self.log.info("Re-check nTx and nChainTx values")
701        check_tx_counts(final=True)
702
703        for i in (0, 1):
704            n = self.nodes[i]
705            self.log.info(f"Restarting node {i} to ensure (Check|Load)BlockIndex passes")
706            with self.assert_disk_cleanup(n, i == 1):
707                self.restart_node(i, extra_args=self.extra_args[i])
708
709            assert_equal(n.getblockchaininfo()["blocks"], FINAL_HEIGHT)
710
711            chainstate, = n.getchainstates()['chainstates']
712            assert_equal(chainstate['blocks'], FINAL_HEIGHT)
713
714            if i != 0:
715                # Ensure indexes have synced for the assumeutxo node
716                self.wait_until(lambda: n.getindexinfo() == completed_idx_state)
717
718
719        # Node 2: all indexes + reindex
720        # -----------------------------
721
722        self.log.info("-- Testing all indexes + reindex")
723        assert_equal(n2.getblockcount(), START_HEIGHT)
724        assert 'NETWORK' in n2.getnetworkinfo()['localservicesnames']  # sanity check
725
726        self.log.info(f"Loading snapshot into third node from {dump_output['path']}")
727        loaded = n2.loadtxoutset(dump_output['path'])
728        assert_equal(loaded['coins_loaded'], SNAPSHOT_BASE_HEIGHT)
729        assert_equal(loaded['base_height'], SNAPSHOT_BASE_HEIGHT)
730
731        # Even though n2 is a full node, it will unset the 'NETWORK' service flag during snapshot loading.
732        # This indicates other peers that the node will temporarily not provide historical blocks.
733        self.log.info("Check node2 updated the local services during snapshot load")
734        self.assert_only_network_limited_service(n2)
735
736        for reindex_arg in ['-reindex=1', '-reindex-chainstate=1']:
737            self.log.info(f"Check that restarting with {reindex_arg} will delete the snapshot chainstate")
738            self.restart_node(2, extra_args=[reindex_arg, *self.extra_args[2]])
739            assert_equal(1, len(n2.getchainstates()["chainstates"]))
740            for i in range(1, 300):
741                block = n0.getblock(n0.getblockhash(i), 0)
742                n2.submitheader(block)
743            loaded = n2.loadtxoutset(dump_output['path'])
744            assert_equal(loaded['coins_loaded'], SNAPSHOT_BASE_HEIGHT)
745            assert_equal(loaded['base_height'], SNAPSHOT_BASE_HEIGHT)
746
747        normal, snapshot = n2.getchainstates()['chainstates']
748        assert_equal(normal['blocks'], START_HEIGHT)
749        assert_equal(normal.get('snapshot_blockhash'), None)
750        assert_equal(normal['validated'], True)