Inside Bitcoin

751
752    // Test that simulating a shutdown (resetting ChainstateManager) and then performing
753    // chainstate reinitializing successfully reloads both chainstates.
754    ChainstateManager& chainman_restarted = this->SimulateNodeRestart();
755
756    BOOST_TEST_MESSAGE("Performing Load/Verify/Activate of chainstate");
757
758    // This call reinitializes the chainstates.
759    this->LoadVerifyActivateChainstate();
760
761    {
762        LOCK(chainman_restarted.GetMutex());
763        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 2);
764        // Background chainstate has height of 109 not 110 here due to a quirk
765        // of the LoadVerifyActivate only calling ActivateBestChain on one
766        // chainstate. The height would be 110 after a real restart, but it's
767        // fine for this test which is focused on the snapshot chainstate.
768        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[0]->m_chain.Height(), 109);
769        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[1]->m_chain.Height(), 210);
770
771        BOOST_CHECK(chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
772        BOOST_CHECK(chainman_restarted.CurrentChainstate().m_assumeutxo == Assumeutxo::UNVALIDATED);
773
774        BOOST_CHECK_EQUAL(chainman_restarted.ActiveTip()->GetBlockHash(), snapshot_tip_hash);
775        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 210);
776        BOOST_CHECK_EQUAL(chainman_restarted.HistoricalChainstate()->m_chain.Height(), 109);
777    }
778
779    BOOST_TEST_MESSAGE(
780        "Ensure we can mine blocks on top of the initialized snapshot chainstate");
781    mineBlocks(10);
782    {
783        LOCK(chainman_restarted.GetMutex());
784        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 220);
785
786        // Background chainstate should be unaware of new blocks on the snapshot
787        // chainstate, but the block disconnected above is now reattached.
788        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 2);
789        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[0]->m_chain.Height(), 110);
790        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates[1]->m_chain.Height(), 220);
791        BOOST_CHECK_EQUAL(chainman_restarted.HistoricalChainstate(), nullptr);
792    }
793}
794
795BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion, SnapshotTestSetup)
796{
797    this->SetupSnapshot();
798
799    ChainstateManager& chainman = *Assert(m_node.chainman);
800    Chainstate& active_cs = chainman.ActiveChainstate();
801    Chainstate& validated_cs{*Assert(WITH_LOCK(cs_main, return chainman.HistoricalChainstate()))};
802    auto tip_cache_before_complete = active_cs.m_coinstip_cache_size_bytes;
803    auto db_cache_before_complete = active_cs.m_coinsdb_cache_size_bytes;
804
805    SnapshotCompletionResult res;
806    m_node.notifications->m_shutdown_on_fatal_error = false;
807
808    fs::path snapshot_chainstate_dir = *node::FindAssumeutxoChainstateDir(chainman.m_options.datadir);
809    BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
810    BOOST_CHECK_EQUAL(snapshot_chainstate_dir, gArgs.GetDataDirNet() / "chainstate_snapshot");
811
812    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
813    const uint256 snapshot_tip_hash = WITH_LOCK(chainman.GetMutex(),
814        return chainman.ActiveTip()->GetBlockHash());
815
816    res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validated_cs, active_cs));
817    BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SUCCESS);
818
819    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_assumeutxo == Assumeutxo::VALIDATED));
820    BOOST_CHECK(WITH_LOCK(::cs_main, return chainman.CurrentChainstate().m_from_snapshot_blockhash));
821    BOOST_CHECK_EQUAL(WITH_LOCK(chainman.GetMutex(), return chainman.HistoricalChainstate()), nullptr);
822
823    // Cache should have been rebalanced and reallocated to the "only" remaining
824    // chainstate.
825    BOOST_CHECK(active_cs.m_coinstip_cache_size_bytes > tip_cache_before_complete);
826    BOOST_CHECK(active_cs.m_coinsdb_cache_size_bytes > db_cache_before_complete);
827
828    // Trying completion again should return false.
829    res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validated_cs, active_cs));
830    BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::SKIPPED);
831
832    // The invalid snapshot path should not have been used.
833    fs::path snapshot_invalid_dir = gArgs.GetDataDirNet() / "chainstate_snapshot_INVALID";
834    BOOST_CHECK(!fs::exists(snapshot_invalid_dir));
835    // chainstate_snapshot should still exist.
836    BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
837
838    // Test that simulating a shutdown (resetting ChainstateManager) and then performing
839    // chainstate reinitializing successfully cleans up the background-validation
840    // chainstate data, and we end up with a single chainstate that is at tip.
841    ChainstateManager& chainman_restarted = this->SimulateNodeRestart();
842
843    BOOST_TEST_MESSAGE("Performing Load/Verify/Activate of chainstate");
844
845    // This call reinitializes the chainstates, and should clean up the now unnecessary
846    // background-validation leveldb contents.
847    this->LoadVerifyActivateChainstate();
848
849    BOOST_CHECK(!fs::exists(snapshot_invalid_dir));
850    // chainstate_snapshot should now *not* exist.
851    BOOST_CHECK(!fs::exists(snapshot_chainstate_dir));
852
853    const Chainstate& active_cs2 = chainman_restarted.ActiveChainstate();
854
855    {
856        LOCK(chainman_restarted.GetMutex());
857        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 1);
858        BOOST_CHECK(!chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
859        BOOST_CHECK(active_cs2.m_coinstip_cache_size_bytes > tip_cache_before_complete);
860        BOOST_CHECK(active_cs2.m_coinsdb_cache_size_bytes > db_cache_before_complete);
861
862        BOOST_CHECK_EQUAL(chainman_restarted.ActiveTip()->GetBlockHash(), snapshot_tip_hash);
863        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 210);
864    }
865
866    BOOST_TEST_MESSAGE(
867        "Ensure we can mine blocks on top of the \"new\" IBD chainstate");
868    mineBlocks(10);
869    {
870        LOCK(chainman_restarted.GetMutex());
871        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 220);
872    }
873}
874
875BOOST_FIXTURE_TEST_CASE(chainstatemanager_snapshot_completion_hash_mismatch, SnapshotTestSetup)
876{
877    auto chainstates = this->SetupSnapshot();
878    Chainstate& validation_chainstate = *std::get<0>(chainstates);
879    Chainstate& unvalidated_cs = *std::get<1>(chainstates);
880    ChainstateManager& chainman = *Assert(m_node.chainman);
881    SnapshotCompletionResult res;
882    m_node.notifications->m_shutdown_on_fatal_error = false;
883
884    // Test tampering with the IBD UTXO set with an extra coin to ensure it causes
885    // snapshot completion to fail.
886    CCoinsViewCache& ibd_coins = WITH_LOCK(::cs_main,
887        return validation_chainstate.CoinsTip());
888    Coin badcoin;
889    badcoin.out.nValue = m_rng.rand32();
890    badcoin.nHeight = 1;
891    badcoin.out.scriptPubKey.assign(m_rng.randbits(6), 0);
892    Txid txid = Txid::FromUint256(m_rng.rand256());
893    ibd_coins.AddCoin(COutPoint(txid, 0), std::move(badcoin), false);
894
895    fs::path snapshot_chainstate_dir = gArgs.GetDataDirNet() / "chainstate_snapshot";
896    BOOST_CHECK(fs::exists(snapshot_chainstate_dir));
897
898    {
899        ASSERT_DEBUG_LOG("failed to validate the -assumeutxo snapshot state");
900        res = WITH_LOCK(::cs_main, return chainman.MaybeValidateSnapshot(validation_chainstate, unvalidated_cs));
901        BOOST_CHECK_EQUAL(res, SnapshotCompletionResult::HASH_MISMATCH);
902    }
903
904    {
905        LOCK(chainman.GetMutex());
906        BOOST_CHECK_EQUAL(chainman.m_chainstates.size(), 2);
907        BOOST_CHECK(chainman.m_chainstates[0]->m_assumeutxo == Assumeutxo::VALIDATED);
908        BOOST_CHECK(!chainman.m_chainstates[0]->SnapshotBase());
909        BOOST_CHECK(chainman.m_chainstates[1]->m_assumeutxo == Assumeutxo::INVALID);
910        BOOST_CHECK(chainman.m_chainstates[1]->SnapshotBase());
911    }
912
913    fs::path snapshot_invalid_dir = gArgs.GetDataDirNet() / "chainstate_snapshot_INVALID";
914    BOOST_CHECK(fs::exists(snapshot_invalid_dir));
915
916    // Test that simulating a shutdown (resetting ChainstateManager) and then performing
917    // chainstate reinitializing successfully loads only the fully-validated
918    // chainstate data, and we end up with a single chainstate that is at tip.
919    ChainstateManager& chainman_restarted = this->SimulateNodeRestart();
920
921    BOOST_TEST_MESSAGE("Performing Load/Verify/Activate of chainstate");
922
923    // This call reinitializes the chainstates, and should clean up the now unnecessary
924    // background-validation leveldb contents.
925    this->LoadVerifyActivateChainstate();
926
927    BOOST_CHECK(fs::exists(snapshot_invalid_dir));
928    BOOST_CHECK(!fs::exists(snapshot_chainstate_dir));
929
930    {
931        LOCK(::cs_main);
932        BOOST_CHECK_EQUAL(chainman_restarted.m_chainstates.size(), 1);
933        BOOST_CHECK(!chainman_restarted.CurrentChainstate().m_from_snapshot_blockhash);
934        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 210);
935    }
936
937    BOOST_TEST_MESSAGE(
938        "Ensure we can mine blocks on top of the \"new\" IBD chainstate");
939    mineBlocks(10);
940    {
941        LOCK(::cs_main);
942        BOOST_CHECK_EQUAL(chainman_restarted.ActiveHeight(), 220);
943    }
944}
945
946/** Helper function to parse args into args_man and return the result of applying them to opts */
947template <typename Options>
948util::Result<Options> SetOptsFromArgs(ArgsManager& args_man, Options opts,
949                                      const std::vector<const char*>& args)
950{
951    const auto argv{Cat({"ignore"}, args)};
952    std::string error{};
953    if (!args_man.ParseParameters(argv.size(), argv.data(), error)) {
954        return util::Error{Untranslated("ParseParameters failed with error: " + error)};
955    }
956    const auto result{node::ApplyArgsManOptions(args_man, opts)};
957    if (!result) return util::Error{util::ErrorString(result)};
958    return opts;
959}
960
961BOOST_FIXTURE_TEST_CASE(chainstatemanager_args, BasicTestingSetup)
962{
963    //! Try to apply the provided args to a ChainstateManager::Options
964    auto get_opts = [&](const std::vector<const char*>& args) {
965        static kernel::Notifications notifications{};
966        static const ChainstateManager::Options options{
967            .chainparams = ::Params(),
968            .datadir = {},
969            .notifications = notifications};
970        return SetOptsFromArgs(*this->m_node.args, options, args);
971    };
972    //! Like get_opts, but requires the provided args to be valid and unwraps the result
973    auto get_valid_opts = [&](const std::vector<const char*>& args) {
974        const auto result{get_opts(args)};
975        BOOST_REQUIRE_MESSAGE(result, util::ErrorString(result).original);
976        return *result;
977    };
978
979    // test -assumevalid
980    BOOST_CHECK(!get_valid_opts({}).assumed_valid_block);
981    BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid="}).assumed_valid_block, uint256::ZERO);
982    BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid=0"}).assumed_valid_block, uint256::ZERO);
983    BOOST_CHECK_EQUAL(get_valid_opts({"-noassumevalid"}).assumed_valid_block, uint256::ZERO);
984    BOOST_CHECK_EQUAL(get_valid_opts({"-assumevalid=0x12"}).assumed_valid_block, uint256{0x12});
985
986    std::string assume_valid{"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"};
987    BOOST_CHECK_EQUAL(get_valid_opts({("-assumevalid=" + assume_valid).c_str()}).assumed_valid_block, uint256::FromHex(assume_valid));
988
989    BOOST_CHECK(!get_opts({"-assumevalid=xyz"}));                                                               // invalid hex characters
990    BOOST_CHECK(!get_opts({"-assumevalid=01234567890123456789012345678901234567890123456789012345678901234"})); // > 64 hex chars
991
992    // test -minimumchainwork
993    BOOST_CHECK(!get_valid_opts({}).minimum_chain_work);
994    BOOST_CHECK_EQUAL(get_valid_opts({"-minimumchainwork=0"}).minimum_chain_work, arith_uint256());
995    BOOST_CHECK_EQUAL(get_valid_opts({"-nominimumchainwork"}).minimum_chain_work, arith_uint256());
996    BOOST_CHECK_EQUAL(get_valid_opts({"-minimumchainwork=0x1234"}).minimum_chain_work, arith_uint256{0x1234});
997
998    std::string minimum_chainwork{"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"};
999    BOOST_CHECK_EQUAL(get_valid_opts({("-minimumchainwork=" + minimum_chainwork).c_str()}).minimum_chain_work, UintToArith256(uint256::FromHex(minimum_chainwork).value()));
1000