Inside Bitcoin

751    auto transactions_copy{transactions};
752    BOOST_CHECK(transactions.begin() == transactions_copy.begin());
753    BOOST_CHECK(transactions.begin() == block_tx.Transactions().begin());
754    auto transaction_it{transactions.begin()};
755    BOOST_CHECK((*transaction_it).Txid() == block_tx.GetTransaction(0).Txid());
756    auto invalid_data = hex_string_to_byte_vec("012300");
757    BOOST_CHECK_THROW(Block{invalid_data}, std::runtime_error);
758    auto empty_data = hex_string_to_byte_vec("");
759    BOOST_CHECK_THROW(Block{empty_data}, std::runtime_error);
760}
761
762Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type, std::shared_ptr<TestValidationInterface> validation_interface = nullptr)
763{
764    ContextOptions options{};
765    ChainParams params{chain_type};
766    options.SetChainParams(params);
767    options.SetNotifications(notifications);
768    if (validation_interface) {
769        options.SetValidationInterface(validation_interface);
770    }
771    auto context{Context{options}};
772    return context;
773}
774
775BOOST_AUTO_TEST_CASE(btck_chainman_tests)
776{
777    Logger logger{std::make_unique<TestLog>()};
778    auto test_directory{TestDirectory{"chainman_test_bitcoin_kernel"}};
779
780    { // test with default context
781        Context context{};
782        ChainstateManagerOptions chainman_opts{context, PathToString(test_directory.m_directory), PathToString(test_directory.m_directory / "blocks")};
783        ChainMan chainman{context, chainman_opts};
784    }
785
786    { // test with default context options
787        ContextOptions options{};
788        Context context{options};
789        ChainstateManagerOptions chainman_opts{context, PathToString(test_directory.m_directory), PathToString(test_directory.m_directory / "blocks")};
790        ChainMan chainman{context, chainman_opts};
791    }
792    { // null or empty data_directory or blocks_directory are not allowed
793        Context context{};
794        auto valid_dir{PathToString(test_directory.m_directory)};
795        std::vector<std::pair<std::string_view, std::string_view>> illegal_cases{
796            {"", valid_dir},
797            {valid_dir, {nullptr, 0}},
798            {"", ""},
799            {{nullptr, 0}, {nullptr, 0}},
800        };
801        for (auto& [data_dir, blocks_dir] : illegal_cases) {
802            BOOST_CHECK_THROW(ChainstateManagerOptions(context, data_dir, blocks_dir),
803                              std::runtime_error);
804        };
805    }
806
807    auto notifications{std::make_shared<TestKernelNotifications>()};
808    auto context{create_context(notifications, ChainType::MAINNET)};
809
810    ChainstateManagerOptions chainman_opts{context, PathToString(test_directory.m_directory), PathToString(test_directory.m_directory / "blocks")};
811    chainman_opts.SetWorkerThreads(4);
812    BOOST_CHECK(!chainman_opts.SetDatabaseCacheBytes(4_MiB - 1));
813    if constexpr (sizeof(void*) == 4) BOOST_CHECK(!chainman_opts.SetDatabaseCacheBytes(2_GiB));
814    BOOST_CHECK(chainman_opts.SetDatabaseCacheBytes(4_MiB));
815    BOOST_CHECK(!chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/false));
816    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/true));
817    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/true));
818    BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/false));
819    ChainMan chainman{context, chainman_opts};
820}
821
822std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
823                                          bool reindex,
824                                          bool wipe_chainstate,
825                                          bool block_tree_db_in_memory,
826                                          bool chainstate_db_in_memory,
827                                          Context& context)
828{
829    ChainstateManagerOptions chainman_opts{context, PathToString(test_directory.m_directory), PathToString(test_directory.m_directory / "blocks")};
830
831    if (reindex) {
832        chainman_opts.SetWipeDbs(/*wipe_block_tree=*/reindex, /*wipe_chainstate=*/reindex);
833    }
834    if (wipe_chainstate) {
835        chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/wipe_chainstate);
836    }
837    if (block_tree_db_in_memory) {
838        chainman_opts.UpdateBlockTreeDbInMemory(block_tree_db_in_memory);
839    }
840    if (chainstate_db_in_memory) {
841        chainman_opts.UpdateChainstateDbInMemory(chainstate_db_in_memory);
842    }
843
844    auto chainman{std::make_unique<ChainMan>(context, chainman_opts)};
845    return chainman;
846}
847
848void chainman_reindex_test(TestDirectory& test_directory)
849{
850    auto notifications{std::make_shared<TestKernelNotifications>()};
851    auto context{create_context(notifications, ChainType::MAINNET)};
852    auto chainman{create_chainman(
853        test_directory, /*reindex=*/true, /*wipe_chainstate=*/false,
854        /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)};
855
856    std::vector<std::string> import_files;
857    BOOST_CHECK(chainman->ImportBlocks(import_files));
858
859    // Sanity check some block retrievals
860    auto chain{chainman->GetChain()};
861    BOOST_CHECK_THROW(chain.GetByHeight(1000), std::runtime_error);
862    auto genesis_index{chain.Entries().front()};
863    BOOST_CHECK(!genesis_index.GetPrevious());
864    auto genesis_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()};
865    auto first_index{chain.GetByHeight(0)};
866    auto first_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()};
867    check_equal(genesis_block_raw, first_block_raw);
868    auto height{first_index.GetHeight()};
869    BOOST_CHECK_EQUAL(height, 0);
870
871    auto next_index{chain.GetByHeight(first_index.GetHeight() + 1)};
872    BOOST_CHECK(chain.Contains(next_index));
873    auto next_block_data{chainman->ReadBlock(next_index).value().ToBytes()};
874    auto tip_index{chain.Entries().back()};
875    auto tip_block_data{chainman->ReadBlock(tip_index).value().ToBytes()};
876    auto second_index{chain.GetByHeight(1)};
877    auto second_block{chainman->ReadBlock(second_index).value()};
878    auto second_block_data{second_block.ToBytes()};
879    auto second_height{second_index.GetHeight()};
880    BOOST_CHECK_EQUAL(second_height, 1);
881    check_equal(next_block_data, tip_block_data);
882    check_equal(next_block_data, second_block_data);
883
884    auto second_hash{second_index.GetHash()};
885    auto another_second_index{chainman->GetBlockTreeEntry(second_hash)};
886    BOOST_CHECK(another_second_index);
887    auto another_second_height{another_second_index->GetHeight()};
888    auto second_block_hash{second_block.GetHash()};
889    check_equal(second_block_hash.ToBytes(), second_hash.ToBytes());
890    BOOST_CHECK_EQUAL(second_height, another_second_height);
891}
892
893void chainman_reindex_chainstate_test(TestDirectory& test_directory)
894{
895    auto notifications{std::make_shared<TestKernelNotifications>()};
896    auto context{create_context(notifications, ChainType::MAINNET)};
897    auto chainman{create_chainman(
898        test_directory, /*reindex=*/false, /*wipe_chainstate=*/true,
899        /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)};
900
901    std::vector<std::string> import_files;
902    import_files.push_back(PathToString(test_directory.m_directory / "blocks" / "blk00000.dat"));
903    BOOST_CHECK(chainman->ImportBlocks(import_files));
904}
905
906void chainman_mainnet_validation_test(TestDirectory& test_directory)
907{
908    auto notifications{std::make_shared<TestKernelNotifications>()};
909    auto validation_interface{std::make_shared<TestValidationInterface>()};
910    auto context{create_context(notifications, ChainType::MAINNET, validation_interface)};
911    auto chainman{create_chainman(
912        test_directory, /*reindex=*/false, /*wipe_chainstate=*/false,
913        /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)};
914
915    // mainnet block 1
916    auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000");
917    Block block{raw_block};
918    BlockHeader header{block.GetHeader()};
919    TransactionView tx{block.GetTransaction(block.CountTransactions() - 1)};
920    BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(tx.Txid().ToBytes()), "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098");
921    BOOST_CHECK_EQUAL(header.Version(), 1);
922    BOOST_CHECK_EQUAL(header.Timestamp(), 1231469665);
923    BOOST_CHECK_EQUAL(header.Bits(), 0x1d00ffff);
924    BOOST_CHECK_EQUAL(header.Nonce(), 2573394689);
925    BOOST_CHECK_EQUAL(tx.CountInputs(), 1);
926    Transaction tx2 = tx;
927    BOOST_CHECK_EQUAL(tx2.CountInputs(), 1);
928    for (auto transaction : block.Transactions()) {
929        BOOST_CHECK_EQUAL(transaction.CountInputs(), 1);
930    }
931    auto output_counts = *(block.Transactions() | std::views::transform([](const auto& tx) {
932                               return tx.CountOutputs();
933                           })).begin();
934    BOOST_CHECK_EQUAL(output_counts, 1);
935
936    validation_interface->m_expected_valid_block.emplace(raw_block);
937    auto ser_block{block.ToBytes()};
938    check_equal(ser_block, raw_block);
939    bool new_block = false;
940    BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
941    BOOST_CHECK(new_block);
942
943    validation_interface->m_expected_valid_block = std::nullopt;
944    new_block = false;
945    Block invalid_block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1])};
946    BOOST_CHECK(!chainman->ProcessBlock(invalid_block, &new_block));
947    BOOST_CHECK(!new_block);
948
949    auto chain{chainman->GetChain()};
950    BOOST_CHECK_EQUAL(chain.Height(), 1);
951    auto tip{chain.Entries().back()};
952    auto read_block{chainman->ReadBlock(tip)};
953    BOOST_REQUIRE(read_block);
954    check_equal(read_block.value().ToBytes(), raw_block);
955
956    // Check that we can read the previous block
957    BlockTreeEntry tip_2{*tip.GetPrevious()};
958    Block read_block_2{*chainman->ReadBlock(tip_2)};
959    BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip_2).Count(), 0);
960    BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip).Count(), 0);
961
962    // It should be an error if we go another block back, since the genesis has no ancestor
963    BOOST_CHECK(!tip_2.GetPrevious());
964
965    // If we try to validate it again, it should be a duplicate
966    BOOST_CHECK(chainman->ProcessBlock(block, &new_block));
967    BOOST_CHECK(!new_block);
968}
969
970BOOST_AUTO_TEST_CASE(btck_check_block_context_free)
971{
972    constexpr size_t MERKLE_ROOT_OFFSET{4 + 32};
973    constexpr size_t NBITS_OFFSET{4 + 32 + 32 + 4};
974    constexpr size_t COINBASE_PREVOUT_N_OFFSET{4 + 32 + 32 + 4 + 4 + 4 + 1 + 4 + 1 + 32};
975
976    // Mainnet block 1
977    auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000");
978
979    // Context-free block checks still need consensus params for the optional
980    // proof-of-work validation path.
981    ChainParams mainnet_params{ChainType::MAINNET};
982    auto consensus_params = mainnet_params.GetConsensusParams();
983
984    Block block{raw_block};
985    BlockValidationState state;
986
987    BOOST_CHECK(block.Check(consensus_params, BlockCheckFlags::BASE, state));
988    BOOST_CHECK(state.GetValidationMode() == ValidationMode::VALID);
989
990    BOOST_CHECK(block.Check(consensus_params, BlockCheckFlags::ALL, state));
991    BOOST_CHECK(state.GetValidationMode() == ValidationMode::VALID);
992
993    auto bad_merkle_block_data = raw_block;
994    bad_merkle_block_data[MERKLE_ROOT_OFFSET] ^= std::byte{0x01};
995    Block bad_merkle_block{bad_merkle_block_data};
996
997    BOOST_CHECK(!bad_merkle_block.Check(consensus_params, BlockCheckFlags::MERKLE, state));
998    BOOST_CHECK(state.GetValidationMode() == ValidationMode::INVALID);
999    BOOST_CHECK(state.GetBlockValidationResult() == BlockValidationResult::MUTATED);
1000