Inside Bitcoin

501        LOCK(chainman.GetMutex());
502        // For completeness, we also reset the block sequence counters to
503        // ensure that no state which affects the ranking of tip-candidates is
504        // retained (even though this isn't strictly necessary).
505        chainman.ResetBlockSequenceCounters();
506        for (const auto& cs : chainman.m_chainstates) {
507            cs->ClearBlockIndexCandidates();
508            BOOST_CHECK(cs->setBlockIndexCandidates.empty());
509        }
510        chainman.LoadBlockIndex();
511        for (const auto& cs : chainman.m_chainstates) {
512            cs->PopulateBlockIndexCandidates();
513        }
514    };
515
516    // Ensure that without any assumed-valid BlockIndex entries, only the current tip is
517    // considered as a candidate.
518    reload_all_block_indexes();
519    BOOST_CHECK_EQUAL(cs1.setBlockIndexCandidates.size(), 1);
520
521    // Reset some region of the chain's nStatus, removing the HAVE_DATA flag.
522    for (int i = 0; i <= cs1.m_chain.Height(); ++i) {
523        LOCK(::cs_main);
524        auto index = cs1.m_chain[i];
525
526        // Blocks with heights in range [91, 110] are marked as missing data.
527        if (i < last_assumed_valid_idx && i >= assumed_valid_start_idx) {
528            index->nStatus = BlockStatus::BLOCK_VALID_TREE;
529            index->nTx = 0;
530            index->m_chain_tx_count = 0;
531        }
532
533        ++num_indexes;
534
535        // Note the last fully-validated block as the expected validated tip.
536        if (i == (assumed_valid_start_idx - 1)) {
537            validated_tip = index;
538        }
539        // Note the last assumed valid block as the snapshot base
540        if (i == last_assumed_valid_idx - 1) {
541            assumed_base = index;
542        }
543    }
544
545    // Note: cs2's tip is not set when ActivateExistingSnapshot is called.
546    Chainstate& cs2{WITH_LOCK(::cs_main, return chainman.AddChainstate(std::make_unique<Chainstate>(nullptr, chainman.m_blockman, chainman, *assumed_base->phashBlock)))};
547
548    // Set tip of the fully validated chain to be the validated tip
549    cs1.m_chain.SetTip(*validated_tip);
550
551    // Set tip of the assume-valid-based chain to the assume-valid block
552    cs2.m_chain.SetTip(*assumed_base);
553
554    // Sanity check test variables.
555    BOOST_CHECK_EQUAL(num_indexes, 121); // 121 total blocks, including genesis
556    BOOST_CHECK_EQUAL(assumed_tip->nHeight, 120);  // original chain has height 120
557    BOOST_CHECK_EQUAL(validated_tip->nHeight, 90); // current cs1 chain has height 90
558    BOOST_CHECK_EQUAL(assumed_base->nHeight, 110); // current cs2 chain has height 110
559
560    // Regenerate cs1.setBlockIndexCandidates and cs2.setBlockIndexCandidate and
561    // check contents below.
562    reload_all_block_indexes();
563
564    // The fully validated chain should only have the current validated tip
565    // as a candidate (block 90). Specifically:
566    //
567    // - It does not have blocks 0-89 because they contain less work than the
568    //   chain tip.
569    //
570    // - It has block 90 because it has data and equal work to the chain tip,
571    //   (since it is the chain tip).
572    //
573    // - It does not have blocks 91-110 because they do not contain data.
574    //
575    // - It does not have any blocks after height 110 because cs1 is a background
576    //   chainstate, and only blocks that are ancestors of the snapshot block
577    //   are added as candidates for the background chainstate.
578    BOOST_CHECK_EQUAL(cs1.setBlockIndexCandidates.size(), 1);
579    BOOST_CHECK_EQUAL(cs1.setBlockIndexCandidates.count(validated_tip), 1);
580
581    // The assumed-valid tolerant chain has the assumed valid base as a
582    // candidate, but otherwise has none of the assumed-valid (which do not
583    // HAVE_DATA) blocks as candidates.
584    //
585    // Specifically:
586    // - All blocks below height 110 are not candidates, because cs2 chain tip
587    //   has height 110 and they have less work than it does.
588    //
589    // - Block 110 is a candidate even though it does not have data, because it
590    //   is the snapshot block, which is assumed valid.
591    //
592    // - Blocks 111-120 are added because they have data.
593
594    // Check that block 90 is absent
595    BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.count(validated_tip), 0);
596    // Check that block 109 is absent
597    BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.count(assumed_base->pprev), 0);
598    // Check that block 110 is present
599    BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.count(assumed_base), 1);
600    // Check that block 120 is present
601    BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.count(assumed_tip), 1);
602    // Check that 11 blocks total are present.
603    BOOST_CHECK_EQUAL(cs2.setBlockIndexCandidates.size(), num_indexes - last_assumed_valid_idx + 1);
604}
605
606BOOST_FIXTURE_TEST_CASE(loadblockindex_invalid_descendants, TestChain100Setup)
607{
608    LOCK(Assert(m_node.chainman)->GetMutex());
609    // consider the chain of blocks grand_parent <- parent <- child
610    // intentionally mark:
611    //   - grand_parent: BLOCK_FAILED_VALID
612    //   - parent: BLOCK_FAILED_CHILD
613    //   - child: not invalid
614    // Test that when the block index is loaded, all blocks are marked as BLOCK_FAILED_VALID
615    auto* child{m_node.chainman->ActiveChain().Tip()};
616    auto* parent{child->pprev};
617    auto* grand_parent{parent->pprev};
618    grand_parent->nStatus = (grand_parent->nStatus | BLOCK_FAILED_VALID);
619    parent->nStatus = (parent->nStatus & ~BLOCK_FAILED_VALID) | BLOCK_FAILED_CHILD;
620    child->nStatus = (child->nStatus & ~BLOCK_FAILED_VALID);
621
622    // Reload block index to recompute block status validity flags.
623    m_node.chainman->LoadBlockIndex();
624
625    // check grand_parent, parent, child is marked as BLOCK_FAILED_VALID after reloading the block index
626    BOOST_CHECK(grand_parent->nStatus & BLOCK_FAILED_VALID);
627    BOOST_CHECK(parent->nStatus & BLOCK_FAILED_VALID);
628    BOOST_CHECK(child->nStatus & BLOCK_FAILED_VALID);
629}
630
631//! Verify that ReconsiderBlock clears failure flags for the target block, its ancestors, and descendants,
632//! but not for sibling forks that diverge from a shared ancestor.
633BOOST_FIXTURE_TEST_CASE(invalidate_block_and_reconsider_fork, TestChain100Setup)
634{
635    ChainstateManager& chainman = *Assert(m_node.chainman);
636    Chainstate& chainstate = chainman.ActiveChainstate();
637
638    // we have a chain of 100 blocks: genesis(0) <- ... <- block98 <- block99 <- block100
639    CBlockIndex* block98;
640    CBlockIndex* block99;
641    CBlockIndex* block100;
642    {
643        LOCK(chainman.GetMutex());
644        block98 = chainman.ActiveChain()[98];
645        block99 = chainman.ActiveChain()[99];
646        block100 = chainman.ActiveChain()[100];
647    }
648
649    // create the following block constellation:
650    // genesis(0) <- ... <- block98 <- block99  <- block100
651    //                              <- block99' <- block100'
652    // by temporarily invalidating block99. the chain tip now falls to block98,
653    // mine 2 new blocks on top of block 98 (block99' and block100') and then restore block99 and block 100.
654    BlockValidationState state;
655    BOOST_REQUIRE(chainstate.InvalidateBlock(state, block99));
656    BOOST_REQUIRE(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip()) == block98);
657    CScript coinbase_script = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
658    for (int i = 0; i < 2; ++i) {
659        CreateAndProcessBlock({}, coinbase_script);
660    }
661    const CBlockIndex* fork_block99;
662    const CBlockIndex* fork_block100;
663    {
664        LOCK(chainman.GetMutex());
665        fork_block99 = chainman.ActiveChain()[99];
666        BOOST_REQUIRE(fork_block99->pprev == block98);
667        fork_block100 = chainman.ActiveChain()[100];
668        BOOST_REQUIRE(fork_block100->pprev == fork_block99);
669    }
670    // Restore original block99 and block100
671    {
672        LOCK(chainman.GetMutex());
673        chainstate.ResetBlockFailureFlags(block99);
674        chainman.RecalculateBestHeader();
675    }
676    chainstate.ActivateBestChain(state);
677    BOOST_REQUIRE(WITH_LOCK(cs_main, return chainman.ActiveChain().Tip()) == block100);
678
679    {
680        LOCK(chainman.GetMutex());
681        BOOST_CHECK(!(block100->nStatus & BLOCK_FAILED_VALID));
682        BOOST_CHECK(!(block99->nStatus & BLOCK_FAILED_VALID));
683        BOOST_CHECK(!(fork_block100->nStatus & BLOCK_FAILED_VALID));
684        BOOST_CHECK(!(fork_block99->nStatus & BLOCK_FAILED_VALID));
685    }
686
687    // Invalidate block98
688    BOOST_REQUIRE(chainstate.InvalidateBlock(state, block98));
689
690    {
691        LOCK(chainman.GetMutex());
692        // block98 and all descendants of block98 are marked BLOCK_FAILED_VALID
693        BOOST_CHECK(block98->nStatus & BLOCK_FAILED_VALID);
694        BOOST_CHECK(block99->nStatus & BLOCK_FAILED_VALID);
695        BOOST_CHECK(block100->nStatus & BLOCK_FAILED_VALID);
696        BOOST_CHECK(fork_block99->nStatus & BLOCK_FAILED_VALID);
697        BOOST_CHECK(fork_block100->nStatus & BLOCK_FAILED_VALID);
698    }
699
700    // Reconsider block99. ResetBlockFailureFlags clears BLOCK_FAILED_VALID from
701    // block99 and its ancestors (block98) and descendants (block100)
702    // but NOT from block99' and block100' (not a direct ancestor/descendant)
703    {
704        LOCK(chainman.GetMutex());
705        chainstate.ResetBlockFailureFlags(block99);
706        chainman.RecalculateBestHeader();
707    }
708    chainstate.ActivateBestChain(state);
709    {
710        LOCK(chainman.GetMutex());
711        BOOST_CHECK(!(block98->nStatus & BLOCK_FAILED_VALID));
712        BOOST_CHECK(!(block99->nStatus & BLOCK_FAILED_VALID));
713        BOOST_CHECK(!(block100->nStatus & BLOCK_FAILED_VALID));
714        BOOST_CHECK(fork_block99->nStatus & BLOCK_FAILED_VALID);
715        BOOST_CHECK(fork_block100->nStatus & BLOCK_FAILED_VALID);
716    }
717}
718
719//! Ensure that snapshot chainstate can be loaded when found on disk after a
720//! restart, and that new blocks can be connected to both chainstates.
721BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_init, SnapshotTestSetup)
722{
723    ChainstateManager& chainman = *Assert(m_node.chainman);
724    Chainstate& bg_chainstate = chainman.ActiveChainstate();
725
726    this->SetupSnapshot();
727
728    fs::path snapshot_chainstate_dir = *node::FindAssumeutxoChainstateDir(chainman.m_options.datadir);
729    BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
730    BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
731
732    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
733    const uint256 snapshot_tip_hash = WITH_LOCK(chainman.GetMutex(),
734        return chainman.ActiveTip()->GetBlockHash());
735
736    BOOST_CHECK_EQUAL(WITH_LOCK(chainman.GetMutex(), return chainman.m_chainstates.size()), 2);
737
738    // "Rewind" the background chainstate so that its tip is not at the
739    // base block of the snapshot - this is so after simulating a node restart,
740    // it will initialize instead of attempting to complete validation.
741    //
742    // Note that this is not a realistic use of DisconnectTip().
743    DisconnectedBlockTransactions unused_pool{MAX_DISCONNECTED_TX_POOL_BYTES};
744    BlockValidationState unused_state;
745    {
746        LOCK2(::cs_main, bg_chainstate.MempoolMutex());
747        BOOST_CHECK(bg_chainstate.DisconnectTip(unused_state, &unused_pool));
748        unused_pool.clear();  // to avoid queuedTx assertion errors on teardown
749    }
750    BOOST_CHECK_EQUAL(bg_chainstate.m_chain.Height(), 109);