test_kernel.cpp
1 // Copyright (c) 2024-present The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <kernel/bitcoinkernel.h> 6 #include <kernel/bitcoinkernel_wrapper.h> 7 8 #define BOOST_TEST_MODULE Bitcoin Kernel Test Suite 9 #include <boost/test/included/unit_test.hpp> 10 11 #include <test/kernel/block_data.h> 12 13 #include <charconv> 14 #include <cstdint> 15 #include <cstdlib> 16 #include <filesystem> 17 #include <iostream> 18 #include <memory> 19 #include <optional> 20 #include <random> 21 #include <ranges> 22 #include <span> 23 #include <string> 24 #include <string_view> 25 #include <vector> 26 27 using namespace btck; 28 29 std::string random_string(uint32_t length) 30 { 31 const std::string chars = "0123456789" 32 "abcdefghijklmnopqrstuvwxyz" 33 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 34 35 static std::random_device rd; 36 static std::default_random_engine dre{rd()}; 37 static std::uniform_int_distribution<> distribution(0, chars.size() - 1); 38 39 std::string random; 40 random.reserve(length); 41 for (uint32_t i = 0; i < length; i++) { 42 random += chars[distribution(dre)]; 43 } 44 return random; 45 } 46 47 std::vector<std::byte> hex_string_to_byte_vec(std::string_view hex) 48 { 49 std::vector<std::byte> bytes; 50 bytes.reserve(hex.length() / 2); 51 52 for (size_t i{0}; i < hex.length(); i += 2) { 53 uint8_t byte_value; 54 auto [ptr, ec] = std::from_chars(hex.data() + i, hex.data() + i + 2, byte_value, 16); 55 56 if (ec != std::errc{} || ptr != hex.data() + i + 2) { 57 throw std::invalid_argument("Invalid hex character"); 58 } 59 bytes.push_back(static_cast<std::byte>(byte_value)); 60 } 61 return bytes; 62 } 63 64 std::string byte_span_to_hex_string_reversed(std::span<const std::byte> bytes) 65 { 66 std::ostringstream oss; 67 68 // Iterate in reverse order 69 for (auto it = bytes.rbegin(); it != bytes.rend(); ++it) { 70 oss << std::hex << std::setw(2) << std::setfill('0') 71 << static_cast<unsigned int>(static_cast<uint8_t>(*it)); 72 } 73 74 return oss.str(); 75 } 76 77 constexpr auto VERIFY_ALL_PRE_SEGWIT{ScriptVerificationFlags::P2SH | ScriptVerificationFlags::DERSIG | 78 ScriptVerificationFlags::NULLDUMMY | ScriptVerificationFlags::CHECKLOCKTIMEVERIFY | 79 ScriptVerificationFlags::CHECKSEQUENCEVERIFY}; 80 constexpr auto VERIFY_ALL_PRE_TAPROOT{VERIFY_ALL_PRE_SEGWIT | ScriptVerificationFlags::WITNESS}; 81 82 void check_equal(std::span<const std::byte> _actual, std::span<const std::byte> _expected, bool equal = true) 83 { 84 std::span<const uint8_t> actual{reinterpret_cast<const unsigned char*>(_actual.data()), _actual.size()}; 85 std::span<const uint8_t> expected{reinterpret_cast<const unsigned char*>(_expected.data()), _expected.size()}; 86 BOOST_CHECK_EQUAL_COLLECTIONS( 87 actual.begin(), actual.end(), 88 expected.begin(), expected.end()); 89 } 90 91 class TestLog 92 { 93 public: 94 void LogMessage(std::string_view message) 95 { 96 std::cout << "kernel: " << message; 97 } 98 }; 99 100 struct TestDirectory { 101 std::filesystem::path m_directory; 102 TestDirectory(std::string directory_name) 103 : m_directory{std::filesystem::temp_directory_path() / (directory_name + random_string(16))} 104 { 105 std::filesystem::create_directories(m_directory); 106 } 107 108 ~TestDirectory() 109 { 110 std::filesystem::remove_all(m_directory); 111 } 112 }; 113 114 class TestKernelNotifications : public KernelNotifications 115 { 116 public: 117 void HeaderTipHandler(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override 118 { 119 BOOST_CHECK_GT(timestamp, 0); 120 } 121 122 void WarningSetHandler(Warning warning, std::string_view message) override 123 { 124 std::cout << "Kernel warning is set: " << message << std::endl; 125 } 126 127 void WarningUnsetHandler(Warning warning) override 128 { 129 std::cout << "Kernel warning was unset." << std::endl; 130 } 131 132 void FlushErrorHandler(std::string_view error) override 133 { 134 std::cout << error << std::endl; 135 } 136 137 void FatalErrorHandler(std::string_view error) override 138 { 139 std::cout << error << std::endl; 140 } 141 }; 142 143 class TestValidationInterface : public ValidationInterface 144 { 145 public: 146 std::optional<std::vector<std::byte>> m_expected_valid_block = std::nullopt; 147 148 void BlockChecked(Block block, BlockValidationStateView state) override 149 { 150 if (m_expected_valid_block.has_value()) { 151 auto ser_block{block.ToBytes()}; 152 check_equal(m_expected_valid_block.value(), ser_block); 153 } 154 155 auto mode{state.GetValidationMode()}; 156 switch (mode) { 157 case ValidationMode::VALID: { 158 std::cout << "Valid block" << std::endl; 159 return; 160 } 161 case ValidationMode::INVALID: { 162 std::cout << "Invalid block: "; 163 auto result{state.GetBlockValidationResult()}; 164 switch (result) { 165 case BlockValidationResult::UNSET: 166 std::cout << "initial value. Block has not yet been rejected" << std::endl; 167 break; 168 case BlockValidationResult::HEADER_LOW_WORK: 169 std::cout << "the block header may be on a too-little-work chain" << std::endl; 170 break; 171 case BlockValidationResult::CONSENSUS: 172 std::cout << "invalid by consensus rules (excluding any below reasons)" << std::endl; 173 break; 174 case BlockValidationResult::CACHED_INVALID: 175 std::cout << "this block was cached as being invalid and we didn't store the reason why" << std::endl; 176 break; 177 case BlockValidationResult::INVALID_HEADER: 178 std::cout << "invalid proof of work or time too old" << std::endl; 179 break; 180 case BlockValidationResult::MUTATED: 181 std::cout << "the block's data didn't match the data committed to by the PoW" << std::endl; 182 break; 183 case BlockValidationResult::MISSING_PREV: 184 std::cout << "We don't have the previous block the checked one is built on" << std::endl; 185 break; 186 case BlockValidationResult::INVALID_PREV: 187 std::cout << "A block this one builds on is invalid" << std::endl; 188 break; 189 case BlockValidationResult::TIME_FUTURE: 190 std::cout << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl; 191 break; 192 } 193 return; 194 } 195 case ValidationMode::INTERNAL_ERROR: { 196 std::cout << "Internal error" << std::endl; 197 return; 198 } 199 } 200 } 201 202 void BlockConnected(Block block, BlockTreeEntry entry) override 203 { 204 std::cout << "Block connected." << std::endl; 205 } 206 207 void PowValidBlock(BlockTreeEntry entry, Block block) override 208 { 209 std::cout << "Block passed pow verification" << std::endl; 210 } 211 212 void BlockDisconnected(Block block, BlockTreeEntry entry) override 213 { 214 std::cout << "Block disconnected." << std::endl; 215 } 216 }; 217 218 void run_verify_test( 219 const ScriptPubkey& spent_script_pubkey, 220 const Transaction& spending_tx, 221 const PrecomputedTransactionData* precomputed_txdata, 222 int64_t amount, 223 unsigned int input_index, 224 bool taproot) 225 { 226 auto status = ScriptVerifyStatus::OK; 227 228 if (taproot) { 229 BOOST_CHECK(spent_script_pubkey.Verify( 230 amount, 231 spending_tx, 232 precomputed_txdata, 233 input_index, 234 ScriptVerificationFlags::ALL, 235 status)); 236 BOOST_CHECK(status == ScriptVerifyStatus::OK); 237 } else { 238 BOOST_CHECK(!spent_script_pubkey.Verify( 239 amount, 240 spending_tx, 241 precomputed_txdata, 242 input_index, 243 ScriptVerificationFlags::ALL, 244 status)); 245 BOOST_CHECK(status == ScriptVerifyStatus::ERROR_SPENT_OUTPUTS_REQUIRED); 246 } 247 248 BOOST_CHECK(spent_script_pubkey.Verify( 249 amount, 250 spending_tx, 251 precomputed_txdata, 252 input_index, 253 VERIFY_ALL_PRE_TAPROOT, 254 status)); 255 BOOST_CHECK(status == ScriptVerifyStatus::OK); 256 257 BOOST_CHECK(spent_script_pubkey.Verify( 258 0, 259 spending_tx, 260 precomputed_txdata, 261 input_index, 262 VERIFY_ALL_PRE_SEGWIT, 263 status)); 264 BOOST_CHECK(status == ScriptVerifyStatus::OK); 265 } 266 267 template <typename T> 268 concept HasToBytes = requires(T t) { t.ToBytes(); }; 269 270 template <typename T> 271 void CheckHandle(T object, T distinct_object) 272 { 273 BOOST_CHECK(object.get() != nullptr); 274 BOOST_CHECK(distinct_object.get() != nullptr); 275 BOOST_CHECK(object.get() != distinct_object.get()); 276 277 if constexpr (HasToBytes<T>) { 278 const auto object_bytes = object.ToBytes(); 279 const auto distinct_bytes = distinct_object.ToBytes(); 280 BOOST_CHECK(!std::ranges::equal(object_bytes, distinct_bytes)); 281 } 282 283 // Copy constructor 284 T object2(distinct_object); 285 BOOST_CHECK_NE(distinct_object.get(), object2.get()); 286 if constexpr (HasToBytes<T>) { 287 check_equal(distinct_object.ToBytes(), object2.ToBytes()); 288 } 289 290 // Copy assignment 291 T object3{distinct_object}; 292 object2 = object3; 293 BOOST_CHECK_NE(object3.get(), object2.get()); 294 if constexpr (HasToBytes<T>) { 295 check_equal(object3.ToBytes(), object2.ToBytes()); 296 } 297 298 // Move constructor 299 auto* original_ptr = object2.get(); 300 T object4{std::move(object2)}; 301 BOOST_CHECK_EQUAL(object4.get(), original_ptr); 302 BOOST_CHECK_EQUAL(object2.get(), nullptr); // NOLINT(bugprone-use-after-move) 303 if constexpr (HasToBytes<T>) { 304 check_equal(object4.ToBytes(), object3.ToBytes()); 305 } 306 307 // Move assignment 308 original_ptr = object4.get(); 309 object2 = std::move(object4); 310 BOOST_CHECK_EQUAL(object2.get(), original_ptr); 311 BOOST_CHECK_EQUAL(object4.get(), nullptr); // NOLINT(bugprone-use-after-move) 312 if constexpr (HasToBytes<T>) { 313 check_equal(object2.ToBytes(), object3.ToBytes()); 314 } 315 } 316 317 template <typename RangeType> 318 requires std::ranges::random_access_range<RangeType> 319 void CheckRange(const RangeType& range, size_t expected_size) 320 { 321 using value_type = std::ranges::range_value_t<RangeType>; 322 323 BOOST_CHECK_EQUAL(range.size(), expected_size); 324 BOOST_REQUIRE(range.size() > 0); // Some checks below assume a non-empty range 325 BOOST_REQUIRE(!range.empty()); 326 327 BOOST_CHECK(range.begin() != range.end()); 328 BOOST_CHECK_EQUAL(std::distance(range.begin(), range.end()), static_cast<std::ptrdiff_t>(expected_size)); 329 BOOST_CHECK(range.cbegin() == range.begin()); 330 BOOST_CHECK(range.cend() == range.end()); 331 332 for (size_t i = 0; i < range.size(); ++i) { 333 BOOST_CHECK_EQUAL(range[i].get(), (*(range.begin() + i)).get()); 334 } 335 336 BOOST_CHECK_THROW(range.at(expected_size), std::out_of_range); 337 338 BOOST_CHECK_EQUAL(range.front().get(), range[0].get()); 339 BOOST_CHECK_EQUAL(range.back().get(), range[expected_size - 1].get()); 340 341 auto it = range.begin(); 342 auto it_copy = it; 343 ++it; 344 BOOST_CHECK(it != it_copy); 345 --it; 346 BOOST_CHECK(it == it_copy); 347 it = range.begin(); 348 auto old_it = it++; 349 BOOST_CHECK(old_it == range.begin()); 350 BOOST_CHECK(it == range.begin() + 1); 351 old_it = it--; 352 BOOST_CHECK(old_it == range.begin() + 1); 353 BOOST_CHECK(it == range.begin()); 354 355 it = range.begin(); 356 it += 2; 357 BOOST_CHECK(it == range.begin() + 2); 358 it -= 2; 359 BOOST_CHECK(it == range.begin()); 360 361 BOOST_CHECK(range.begin() < range.end()); 362 BOOST_CHECK(range.begin() <= range.end()); 363 BOOST_CHECK(range.end() > range.begin()); 364 BOOST_CHECK(range.end() >= range.begin()); 365 BOOST_CHECK(range.begin() == range.begin()); 366 367 BOOST_CHECK_EQUAL(range.begin()[0].get(), range[0].get()); 368 369 size_t count = 0; 370 for (auto rit = range.end(); rit != range.begin();) { 371 --rit; 372 ++count; 373 } 374 BOOST_CHECK_EQUAL(count, expected_size); 375 376 std::vector<value_type> collected; 377 for (const auto& elem : range) { 378 collected.push_back(elem); 379 } 380 BOOST_CHECK_EQUAL(collected.size(), expected_size); 381 382 BOOST_CHECK_EQUAL(std::ranges::size(range), expected_size); 383 384 it = range.begin(); 385 auto it2 = 1 + it; 386 BOOST_CHECK(it2 == it + 1); 387 } 388 389 BOOST_AUTO_TEST_CASE(btck_transaction_tests) 390 { 391 auto tx_data{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")}; 392 auto tx{Transaction{tx_data}}; 393 auto tx_data_2{hex_string_to_byte_vec("02000000000101904f4ee5c87d20090b642f116e458cd6693292ad9ece23e72f15fb6c05b956210500000000fdffffff02e2010000000000002251200839a723933b56560487ec4d67dda58f09bae518ffa7e148313c5696ac837d9f10060000000000002251205826bcdae7abfb1c468204170eab00d887b61ab143464a4a09e1450bdc59a3340140f26e7af574e647355830772946356c27e7bbc773c5293688890f58983499581be84de40be7311a14e6d6422605df086620e75adae84ff06b75ce5894de5e994a00000000")}; 394 auto tx2{Transaction{tx_data_2}}; 395 CheckHandle(tx, tx2); 396 397 auto invalid_data = hex_string_to_byte_vec("012300"); 398 BOOST_CHECK_THROW(Transaction{invalid_data}, std::runtime_error); 399 auto empty_data = hex_string_to_byte_vec(""); 400 BOOST_CHECK_THROW(Transaction{empty_data}, std::runtime_error); 401 402 BOOST_CHECK_EQUAL(tx.CountOutputs(), 2); 403 BOOST_CHECK_EQUAL(tx.CountInputs(), 1); 404 auto broken_tx_data{std::span<std::byte>{tx_data.begin(), tx_data.begin() + 10}}; 405 BOOST_CHECK_THROW(Transaction{broken_tx_data}, std::runtime_error); 406 auto output{tx.GetOutput(tx.CountOutputs() - 1)}; 407 BOOST_CHECK_EQUAL(output.Amount(), 42130042); 408 auto script_pubkey{output.GetScriptPubkey()}; 409 { 410 auto tx_new{Transaction{tx_data}}; 411 // This is safe, because we now use copy assignment 412 TransactionOutput output = tx_new.GetOutput(tx_new.CountOutputs() - 1); 413 ScriptPubkey script = output.GetScriptPubkey(); 414 415 TransactionOutputView output2 = tx_new.GetOutput(tx_new.CountOutputs() - 1); 416 BOOST_CHECK_NE(output.get(), output2.get()); 417 BOOST_CHECK_EQUAL(output.Amount(), output2.Amount()); 418 TransactionOutput output3 = output2; 419 BOOST_CHECK_NE(output3.get(), output2.get()); 420 BOOST_CHECK_EQUAL(output3.Amount(), output2.Amount()); 421 422 // Non-owned view 423 ScriptPubkeyView script2 = output.GetScriptPubkey(); 424 BOOST_CHECK_NE(script.get(), script2.get()); 425 check_equal(script.ToBytes(), script2.ToBytes()); 426 427 // Non-owned to owned 428 ScriptPubkey script3 = script2; 429 BOOST_CHECK_NE(script3.get(), script2.get()); 430 check_equal(script3.ToBytes(), script2.ToBytes()); 431 } 432 BOOST_CHECK_EQUAL(output.Amount(), 42130042); 433 434 auto tx_roundtrip{Transaction{tx.ToBytes()}}; 435 check_equal(tx_roundtrip.ToBytes(), tx_data); 436 437 // The following code is unsafe, but left here to show limitations of the 438 // API, because we preserve the output view beyond the lifetime of the 439 // transaction. The view type wrapper should make this clear to the user. 440 // auto get_output = [&]() -> TransactionOutputView { 441 // auto tx{Transaction{tx_data}}; 442 // return tx.GetOutput(0); 443 // }; 444 // auto output_new = get_output(); 445 // BOOST_CHECK_EQUAL(output_new.Amount(), 20737411); 446 447 int64_t total_amount{0}; 448 for (const auto output : tx.Outputs()) { 449 total_amount += output.Amount(); 450 } 451 BOOST_CHECK_EQUAL(total_amount, 62867453); 452 453 auto amount = *(tx.Outputs() | std::ranges::views::filter([](const auto& output) { 454 return output.Amount() == 42130042; 455 }) | 456 std::views::transform([](const auto& output) { 457 return output.Amount(); 458 })).begin(); 459 BOOST_REQUIRE(amount); 460 BOOST_CHECK_EQUAL(amount, 42130042); 461 462 CheckRange(tx.Outputs(), tx.CountOutputs()); 463 464 ScriptPubkey script_pubkey_roundtrip{script_pubkey.ToBytes()}; 465 check_equal(script_pubkey_roundtrip.ToBytes(), script_pubkey.ToBytes()); 466 } 467 468 BOOST_AUTO_TEST_CASE(btck_script_pubkey) 469 { 470 auto script_data{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")}; 471 std::vector<std::byte> script_data_2 = script_data; 472 script_data_2.push_back(std::byte{0x51}); 473 ScriptPubkey script{script_data}; 474 ScriptPubkey script2{script_data_2}; 475 CheckHandle(script, script2); 476 477 std::span<std::byte> empty_data{}; 478 ScriptPubkey empty_script{empty_data}; 479 CheckHandle(script, empty_script); 480 } 481 482 BOOST_AUTO_TEST_CASE(btck_transaction_output) 483 { 484 ScriptPubkey script{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")}; 485 TransactionOutput output{script, 1}; 486 TransactionOutput output2{script, 2}; 487 CheckHandle(output, output2); 488 } 489 490 BOOST_AUTO_TEST_CASE(btck_transaction_input) 491 { 492 Transaction tx{hex_string_to_byte_vec("020000000248c03e66fd371c7033196ce24298628e59ebefa00363026044e0f35e0325a65d000000006a473044022004893432347f39beaa280e99da595681ddb20fc45010176897e6e055d716dbfa022040a9e46648a5d10c33ef7cee5e6cf4b56bd513eae3ae044f0039824b02d0f44c012102982331a52822fd9b62e9b5d120da1d248558fac3da3a3c51cd7d9c8ad3da760efeffffffb856678c6e4c3c84e39e2ca818807049d6fba274b42af3c6d3f9d4b6513212d2000000006a473044022068bcedc7fe39c9f21ad318df2c2da62c2dc9522a89c28c8420ff9d03d2e6bf7b0220132afd752754e5cb1ea2fd0ed6a38ec666781e34b0e93dc9a08f2457842cf5660121033aeb9c079ea3e08ea03556182ab520ce5c22e6b0cb95cee6435ee17144d860cdfeffffff0260d50b00000000001976a914363cc8d55ea8d0500de728ef6d63804ddddbdc9888ac67040f00000000001976a914c303bdc5064bf9c9a8b507b5496bd0987285707988ac6acb0700")}; 493 TransactionInput input_0 = tx.GetInput(0); 494 TransactionInput input_1 = tx.GetInput(1); 495 CheckHandle(input_0, input_1); 496 CheckRange(tx.Inputs(), tx.CountInputs()); 497 OutPoint point_0 = input_0.OutPoint(); 498 OutPoint point_1 = input_1.OutPoint(); 499 CheckHandle(point_0, point_1); 500 } 501 502 BOOST_AUTO_TEST_CASE(btck_precomputed_txdata) { 503 auto tx_data{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")}; 504 auto tx{Transaction{tx_data}}; 505 auto tx_data_2{hex_string_to_byte_vec("02000000000101904f4ee5c87d20090b642f116e458cd6693292ad9ece23e72f15fb6c05b956210500000000fdffffff02e2010000000000002251200839a723933b56560487ec4d67dda58f09bae518ffa7e148313c5696ac837d9f10060000000000002251205826bcdae7abfb1c468204170eab00d887b61ab143464a4a09e1450bdc59a3340140f26e7af574e647355830772946356c27e7bbc773c5293688890f58983499581be84de40be7311a14e6d6422605df086620e75adae84ff06b75ce5894de5e994a00000000")}; 506 auto tx2{Transaction{tx_data_2}}; 507 auto precomputed_txdata{PrecomputedTransactionData{ 508 /*tx_to=*/tx, 509 /*spent_outputs=*/{}, 510 }}; 511 auto precomputed_txdata_2{PrecomputedTransactionData{ 512 /*tx_to=*/tx2, 513 /*spent_outputs=*/{}, 514 }}; 515 CheckHandle(precomputed_txdata, precomputed_txdata_2); 516 } 517 518 BOOST_AUTO_TEST_CASE(btck_script_verify_tests) 519 { 520 // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d 521 auto legacy_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("76a9144bfbaf6afb76cc5771bc6404810d1cc041a6933988ac")}}; 522 auto legacy_spending_tx{Transaction{hex_string_to_byte_vec("02000000013f7cebd65c27431a90bba7f796914fe8cc2ddfc3f2cbd6f7e5f2fc854534da95000000006b483045022100de1ac3bcdfb0332207c4a91f3832bd2c2915840165f876ab47c5f8996b971c3602201c6c053d750fadde599e6f5c4e1963df0f01fc0d97815e8157e3d59fe09ca30d012103699b464d1d8bc9e47d4fb1cdaa89a1c5783d68363c4dbc4b524ed3d857148617feffffff02836d3c01000000001976a914fc25d6d5c94003bf5b0c7b640a248e2c637fcfb088ac7ada8202000000001976a914fbed3d9b11183209a57999d54d59f67c019e756c88ac6acb0700")}}; 523 run_verify_test( 524 /*spent_script_pubkey=*/legacy_spent_script_pubkey, 525 /*spending_tx=*/legacy_spending_tx, 526 /*precomputed_txdata=*/nullptr, 527 /*amount=*/0, 528 /*input_index=*/0, 529 /*taproot=*/false); 530 531 // Legacy transaction aca326a724eda9a461c10a876534ecd5ae7b27f10f26c3862fb996f80ea2d45d with precomputed_txdata 532 auto legacy_precomputed_txdata{PrecomputedTransactionData{ 533 /*tx_to=*/legacy_spending_tx, 534 /*spent_outputs=*/{}, 535 }}; 536 run_verify_test( 537 /*spent_script_pubkey=*/legacy_spent_script_pubkey, 538 /*spending_tx=*/legacy_spending_tx, 539 /*precomputed_txdata=*/&legacy_precomputed_txdata, 540 /*amount=*/0, 541 /*input_index=*/0, 542 /*taproot=*/false); 543 544 // Segwit transaction 1a3e89644985fbbb41e0dcfe176739813542b5937003c46a07de1e3ee7a4a7f3 545 auto segwit_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d")}}; 546 auto segwit_spending_tx{Transaction{hex_string_to_byte_vec("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000")}}; 547 run_verify_test( 548 /*spent_script_pubkey=*/segwit_spent_script_pubkey, 549 /*spending_tx=*/segwit_spending_tx, 550 /*precomputed_txdata=*/nullptr, 551 /*amount=*/18393430, 552 /*input_index=*/0, 553 /*taproot=*/false); 554 555 // Segwit transaction 1a3e89644985fbbb41e0dcfe176739813542b5937003c46a07de1e3ee7a4a7f3 with precomputed_txdata 556 auto segwit_precomputed_txdata{PrecomputedTransactionData{ 557 /*tx_to=*/segwit_spending_tx, 558 /*spent_outputs=*/{}, 559 }}; 560 run_verify_test( 561 /*spent_script_pubkey=*/segwit_spent_script_pubkey, 562 /*spending_tx=*/segwit_spending_tx, 563 /*precomputed_txdata=*/&segwit_precomputed_txdata, 564 /*amount=*/18393430, 565 /*input_index=*/0, 566 /*taproot=*/false); 567 568 // Taproot transaction 33e794d097969002ee05d336686fc03c9e15a597c1b9827669460fac98799036 569 auto taproot_spent_script_pubkey{ScriptPubkey{hex_string_to_byte_vec("5120339ce7e165e67d93adb3fef88a6d4beed33f01fa876f05a225242b82a631abc0")}}; 570 auto taproot_spending_tx{Transaction{hex_string_to_byte_vec("01000000000101d1f1c1f8cdf6759167b90f52c9ad358a369f95284e841d7a2536cef31c0549580100000000fdffffff020000000000000000316a2f49206c696b65205363686e6f7272207369677320616e6420492063616e6e6f74206c69652e204062697462756734329e06010000000000225120a37c3903c8d0db6512e2b40b0dffa05e5a3ab73603ce8c9c4b7771e5412328f90140a60c383f71bac0ec919b1d7dbc3eb72dd56e7aa99583615564f9f99b8ae4e837b758773a5b2e4c51348854c8389f008e05029db7f464a5ff2e01d5e6e626174affd30a00")}}; 571 std::vector<TransactionOutput> taproot_spent_outputs; 572 taproot_spent_outputs.emplace_back(taproot_spent_script_pubkey, 88480); 573 auto taproot_precomputed_txdata{PrecomputedTransactionData{ 574 /*tx_to=*/taproot_spending_tx, 575 /*spent_outputs=*/taproot_spent_outputs, 576 }}; 577 run_verify_test( 578 /*spent_script_pubkey=*/taproot_spent_script_pubkey, 579 /*spending_tx=*/taproot_spending_tx, 580 /*precomputed_txdata=*/&taproot_precomputed_txdata, 581 /*amount=*/88480, 582 /*input_index=*/0, 583 /*taproot=*/true); 584 585 // Two-input taproot transaction e8e8320f40c31ed511570e9cdf1d241f8ec9a5cc392e6105240ac8dbea2098de 586 auto taproot2_spent_script_pubkey0{ScriptPubkey{hex_string_to_byte_vec("5120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e")}}; 587 auto taproot2_spent_script_pubkey1{ScriptPubkey{hex_string_to_byte_vec("5120ab78e077d062e7b8acd7063668b4db5355a1b5d5fd2a46a8e98e62e5e63fab77")}}; 588 auto taproot2_spending_tx{Transaction{hex_string_to_byte_vec("02000000000102c0f01ead18750892c84b1d4f595149ad38f16847df1fbf490e235b3b78c1f98a0100000000ffffffff456764a19c2682bf5b1567119f06a421849ad1664cf42b5ef95b69d6e2159e9d0000000000ffffffff022202000000000000225120b6c0c2a8ee25a2ae0322ab7f1a06f01746f81f6b90d179c3c2a51a356e6188f1d70e020000000000225120b7da80f57e36930b0515eb09293e25858d13e6b91fee6184943f5a584cb4248e0141933fdc49eb1af1f08ed1e9cf5559259309a8acd25ff1e6999b6955124438aef4fceaa4e6a5f85286631e24837329563595bc3cf4b31e1c687442abb01c4206818101401c9620faf1e8c84187762ad14d04ae3857f59a2f03f1dcbb99290e16dfc572a63b4ea435780a5787af59beb5742fd71cda8a95381517a1ff14b4c67996c4bf8100000000")}}; 589 std::vector<TransactionOutput> taproot2_spent_outputs; 590 taproot2_spent_outputs.emplace_back(taproot2_spent_script_pubkey0, 546); 591 taproot2_spent_outputs.emplace_back(taproot2_spent_script_pubkey1, 135125); 592 auto taproot2_precomputed_txdata{PrecomputedTransactionData{ 593 /*tx_to=*/taproot2_spending_tx, 594 /*spent_outputs=*/taproot2_spent_outputs, 595 }}; 596 run_verify_test( 597 /*spent_script_pubkey=*/taproot2_spent_script_pubkey0, 598 /*spending_tx=*/taproot2_spending_tx, 599 /*precomputed_txdata=*/&taproot2_precomputed_txdata, 600 /*amount=*/546, 601 /*input_index=*/0, 602 /*taproot=*/true); 603 run_verify_test( 604 /*spent_script_pubkey=*/taproot2_spent_script_pubkey1, 605 /*spending_tx=*/taproot2_spending_tx, 606 /*precomputed_txdata=*/&taproot2_precomputed_txdata, 607 /*amount=*/135125, 608 /*input_index=*/1, 609 /*taproot=*/true); 610 } 611 612 BOOST_AUTO_TEST_CASE(logging_tests) 613 { 614 btck_LoggingOptions logging_options = { 615 .log_timestamps = true, 616 .log_time_micros = true, 617 .log_threadnames = false, 618 .log_sourcelocations = false, 619 .always_print_category_levels = true, 620 }; 621 622 logging_set_options(logging_options); 623 logging_set_level_category(LogCategory::BENCH, LogLevel::TRACE_LEVEL); 624 logging_disable_category(LogCategory::BENCH); 625 logging_enable_category(LogCategory::VALIDATION); 626 logging_disable_category(LogCategory::VALIDATION); 627 628 // Check that connecting, connecting another, and then disconnecting and connecting a logger again works. 629 { 630 logging_set_level_category(LogCategory::KERNEL, LogLevel::TRACE_LEVEL); 631 logging_enable_category(LogCategory::KERNEL); 632 Logger logger{std::make_unique<TestLog>()}; 633 Logger logger_2{std::make_unique<TestLog>()}; 634 } 635 Logger logger{std::make_unique<TestLog>()}; 636 } 637 638 BOOST_AUTO_TEST_CASE(btck_context_tests) 639 { 640 { // test default context 641 Context context{}; 642 Context context2{}; 643 CheckHandle(context, context2); 644 } 645 646 { // test with context options, but not options set 647 ContextOptions options{}; 648 Context context{options}; 649 } 650 651 { // test with context options 652 ContextOptions options{}; 653 ChainParams params{ChainType::MAINNET}; 654 ChainParams regtest_params{ChainType::REGTEST}; 655 CheckHandle(params, regtest_params); 656 options.SetChainParams(params); 657 options.SetNotifications(std::make_shared<TestKernelNotifications>()); 658 Context context{options}; 659 } 660 } 661 662 BOOST_AUTO_TEST_CASE(btck_block_header_tests) 663 { 664 // Block header format: version(4) + prev_hash(32) + merkle_root(32) + timestamp(4) + bits(4) + nonce(4) = 80 bytes 665 BlockHeader header_0{hex_string_to_byte_vec("00e07a26beaaeee2e71d7eb19279545edbaf15de0999983626ec00000000000000000000579cf78b65229bfb93f4a11463af2eaa5ad91780f27f5d147a423bea5f7e4cdf2a47e268b4dd01173a9662ee")}; 666 BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(header_0.Hash().ToBytes()), "00000000000000000000325c7e14a4ee3b4fcb2343089a839287308a0ddbee4f"); 667 BlockHeader header_1{hex_string_to_byte_vec("00c00020e7cb7b4de21d26d55bd384017b8bb9333ac3b2b55bed00000000000000000000d91b4484f801b99f03d36b9d26cfa83420b67f81da12d7e6c1e7f364e743c5ba9946e268b4dd011799c8533d")}; 668 CheckHandle(header_0, header_1); 669 670 // Test error handling for invalid data 671 BOOST_CHECK_THROW(BlockHeader{hex_string_to_byte_vec("00")}, std::runtime_error); 672 BOOST_CHECK_THROW(BlockHeader{hex_string_to_byte_vec("")}, std::runtime_error); 673 674 // Test all header field accessors using mainnet block 1 675 auto mainnet_block_1_header = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e36299"); 676 BlockHeader header{mainnet_block_1_header}; 677 BOOST_CHECK_EQUAL(header.Version(), 1); 678 BOOST_CHECK_EQUAL(header.Timestamp(), 1231469665); 679 BOOST_CHECK_EQUAL(header.Bits(), 0x1d00ffff); 680 BOOST_CHECK_EQUAL(header.Nonce(), 2573394689); 681 BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(header.Hash().ToBytes()), "00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048"); 682 auto prev_hash = header.PrevHash(); 683 BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(prev_hash.ToBytes()), "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"); 684 685 auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000"); 686 Block block{raw_block}; 687 BlockHeader block_header{block.GetHeader()}; 688 BOOST_CHECK_EQUAL(block_header.Version(), 1); 689 BOOST_CHECK_EQUAL(block_header.Timestamp(), 1231469665); 690 BOOST_CHECK_EQUAL(block_header.Bits(), 0x1d00ffff); 691 BOOST_CHECK_EQUAL(block_header.Nonce(), 2573394689); 692 BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(block_header.Hash().ToBytes()), "00000000839a8e6886ab5951d76f411475428afc90947ee320161bbf18eb6048"); 693 } 694 695 BOOST_AUTO_TEST_CASE(btck_block) 696 { 697 Block block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[0])}; 698 Block block_100{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[100])}; 699 CheckHandle(block, block_100); 700 Block block_tx{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[205])}; 701 CheckRange(block_tx.Transactions(), block_tx.CountTransactions()); 702 auto invalid_data = hex_string_to_byte_vec("012300"); 703 BOOST_CHECK_THROW(Block{invalid_data}, std::runtime_error); 704 auto empty_data = hex_string_to_byte_vec(""); 705 BOOST_CHECK_THROW(Block{empty_data}, std::runtime_error); 706 } 707 708 Context create_context(std::shared_ptr<TestKernelNotifications> notifications, ChainType chain_type, std::shared_ptr<TestValidationInterface> validation_interface = nullptr) 709 { 710 ContextOptions options{}; 711 ChainParams params{chain_type}; 712 options.SetChainParams(params); 713 options.SetNotifications(notifications); 714 if (validation_interface) { 715 options.SetValidationInterface(validation_interface); 716 } 717 auto context{Context{options}}; 718 return context; 719 } 720 721 BOOST_AUTO_TEST_CASE(btck_chainman_tests) 722 { 723 Logger logger{std::make_unique<TestLog>()}; 724 auto test_directory{TestDirectory{"chainman_test_bitcoin_kernel"}}; 725 726 { // test with default context 727 Context context{}; 728 ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()}; 729 ChainMan chainman{context, chainman_opts}; 730 } 731 732 { // test with default context options 733 ContextOptions options{}; 734 Context context{options}; 735 ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()}; 736 ChainMan chainman{context, chainman_opts}; 737 } 738 { // null or empty data_directory or blocks_directory are not allowed 739 Context context{}; 740 auto valid_dir{test_directory.m_directory.string()}; 741 std::vector<std::pair<std::string_view, std::string_view>> illegal_cases{ 742 {"", valid_dir}, 743 {valid_dir, {nullptr, 0}}, 744 {"", ""}, 745 {{nullptr, 0}, {nullptr, 0}}, 746 }; 747 for (auto& [data_dir, blocks_dir] : illegal_cases) { 748 BOOST_CHECK_THROW(ChainstateManagerOptions(context, data_dir, blocks_dir), 749 std::runtime_error); 750 }; 751 } 752 753 auto notifications{std::make_shared<TestKernelNotifications>()}; 754 auto context{create_context(notifications, ChainType::MAINNET)}; 755 756 ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()}; 757 chainman_opts.SetWorkerThreads(4); 758 BOOST_CHECK(!chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/false)); 759 BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/true, /*wipe_chainstate=*/true)); 760 BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/true)); 761 BOOST_CHECK(chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/false)); 762 ChainMan chainman{context, chainman_opts}; 763 } 764 765 std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory, 766 bool reindex, 767 bool wipe_chainstate, 768 bool block_tree_db_in_memory, 769 bool chainstate_db_in_memory, 770 Context& context) 771 { 772 ChainstateManagerOptions chainman_opts{context, test_directory.m_directory.string(), (test_directory.m_directory / "blocks").string()}; 773 774 if (reindex) { 775 chainman_opts.SetWipeDbs(/*wipe_block_tree=*/reindex, /*wipe_chainstate=*/reindex); 776 } 777 if (wipe_chainstate) { 778 chainman_opts.SetWipeDbs(/*wipe_block_tree=*/false, /*wipe_chainstate=*/wipe_chainstate); 779 } 780 if (block_tree_db_in_memory) { 781 chainman_opts.UpdateBlockTreeDbInMemory(block_tree_db_in_memory); 782 } 783 if (chainstate_db_in_memory) { 784 chainman_opts.UpdateChainstateDbInMemory(chainstate_db_in_memory); 785 } 786 787 auto chainman{std::make_unique<ChainMan>(context, chainman_opts)}; 788 return chainman; 789 } 790 791 void chainman_reindex_test(TestDirectory& test_directory) 792 { 793 auto notifications{std::make_shared<TestKernelNotifications>()}; 794 auto context{create_context(notifications, ChainType::MAINNET)}; 795 auto chainman{create_chainman( 796 test_directory, /*reindex=*/true, /*wipe_chainstate=*/false, 797 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 798 799 std::vector<std::string> import_files; 800 BOOST_CHECK(chainman->ImportBlocks(import_files)); 801 802 // Sanity check some block retrievals 803 auto chain{chainman->GetChain()}; 804 BOOST_CHECK_THROW(chain.GetByHeight(1000), std::runtime_error); 805 auto genesis_index{chain.Entries().front()}; 806 BOOST_CHECK(!genesis_index.GetPrevious()); 807 auto genesis_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()}; 808 auto first_index{chain.GetByHeight(0)}; 809 auto first_block_raw{chainman->ReadBlock(genesis_index).value().ToBytes()}; 810 check_equal(genesis_block_raw, first_block_raw); 811 auto height{first_index.GetHeight()}; 812 BOOST_CHECK_EQUAL(height, 0); 813 814 auto next_index{chain.GetByHeight(first_index.GetHeight() + 1)}; 815 BOOST_CHECK(chain.Contains(next_index)); 816 auto next_block_data{chainman->ReadBlock(next_index).value().ToBytes()}; 817 auto tip_index{chain.Entries().back()}; 818 auto tip_block_data{chainman->ReadBlock(tip_index).value().ToBytes()}; 819 auto second_index{chain.GetByHeight(1)}; 820 auto second_block{chainman->ReadBlock(second_index).value()}; 821 auto second_block_data{second_block.ToBytes()}; 822 auto second_height{second_index.GetHeight()}; 823 BOOST_CHECK_EQUAL(second_height, 1); 824 check_equal(next_block_data, tip_block_data); 825 check_equal(next_block_data, second_block_data); 826 827 auto second_hash{second_index.GetHash()}; 828 auto another_second_index{chainman->GetBlockTreeEntry(second_hash)}; 829 BOOST_CHECK(another_second_index); 830 auto another_second_height{another_second_index->GetHeight()}; 831 auto second_block_hash{second_block.GetHash()}; 832 check_equal(second_block_hash.ToBytes(), second_hash.ToBytes()); 833 BOOST_CHECK_EQUAL(second_height, another_second_height); 834 } 835 836 void chainman_reindex_chainstate_test(TestDirectory& test_directory) 837 { 838 auto notifications{std::make_shared<TestKernelNotifications>()}; 839 auto context{create_context(notifications, ChainType::MAINNET)}; 840 auto chainman{create_chainman( 841 test_directory, /*reindex=*/false, /*wipe_chainstate=*/true, 842 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 843 844 std::vector<std::string> import_files; 845 import_files.push_back((test_directory.m_directory / "blocks" / "blk00000.dat").string()); 846 BOOST_CHECK(chainman->ImportBlocks(import_files)); 847 } 848 849 void chainman_mainnet_validation_test(TestDirectory& test_directory) 850 { 851 auto notifications{std::make_shared<TestKernelNotifications>()}; 852 auto validation_interface{std::make_shared<TestValidationInterface>()}; 853 auto context{create_context(notifications, ChainType::MAINNET, validation_interface)}; 854 auto chainman{create_chainman( 855 test_directory, /*reindex=*/false, /*wipe_chainstate=*/false, 856 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 857 858 // mainnet block 1 859 auto raw_block = hex_string_to_byte_vec("010000006fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000982051fd1e4ba744bbbe680e1fee14677ba1a3c3540bf7b1cdb606e857233e0e61bc6649ffff001d01e362990101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0704ffff001d0104ffffffff0100f2052a0100000043410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac00000000"); 860 Block block{raw_block}; 861 BlockHeader header{block.GetHeader()}; 862 TransactionView tx{block.GetTransaction(block.CountTransactions() - 1)}; 863 BOOST_CHECK_EQUAL(byte_span_to_hex_string_reversed(tx.Txid().ToBytes()), "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"); 864 BOOST_CHECK_EQUAL(header.Version(), 1); 865 BOOST_CHECK_EQUAL(header.Timestamp(), 1231469665); 866 BOOST_CHECK_EQUAL(header.Bits(), 0x1d00ffff); 867 BOOST_CHECK_EQUAL(header.Nonce(), 2573394689); 868 BOOST_CHECK_EQUAL(tx.CountInputs(), 1); 869 Transaction tx2 = tx; 870 BOOST_CHECK_EQUAL(tx2.CountInputs(), 1); 871 for (auto transaction : block.Transactions()) { 872 BOOST_CHECK_EQUAL(transaction.CountInputs(), 1); 873 } 874 auto output_counts = *(block.Transactions() | std::views::transform([](const auto& tx) { 875 return tx.CountOutputs(); 876 })).begin(); 877 BOOST_CHECK_EQUAL(output_counts, 1); 878 879 validation_interface->m_expected_valid_block.emplace(raw_block); 880 auto ser_block{block.ToBytes()}; 881 check_equal(ser_block, raw_block); 882 bool new_block = false; 883 BOOST_CHECK(chainman->ProcessBlock(block, &new_block)); 884 BOOST_CHECK(new_block); 885 886 validation_interface->m_expected_valid_block = std::nullopt; 887 new_block = false; 888 Block invalid_block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1])}; 889 BOOST_CHECK(!chainman->ProcessBlock(invalid_block, &new_block)); 890 BOOST_CHECK(!new_block); 891 892 auto chain{chainman->GetChain()}; 893 BOOST_CHECK_EQUAL(chain.Height(), 1); 894 auto tip{chain.Entries().back()}; 895 auto read_block{chainman->ReadBlock(tip)}; 896 BOOST_REQUIRE(read_block); 897 check_equal(read_block.value().ToBytes(), raw_block); 898 899 // Check that we can read the previous block 900 BlockTreeEntry tip_2{*tip.GetPrevious()}; 901 Block read_block_2{*chainman->ReadBlock(tip_2)}; 902 BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip_2).Count(), 0); 903 BOOST_CHECK_EQUAL(chainman->ReadBlockSpentOutputs(tip).Count(), 0); 904 905 // It should be an error if we go another block back, since the genesis has no ancestor 906 BOOST_CHECK(!tip_2.GetPrevious()); 907 908 // If we try to validate it again, it should be a duplicate 909 BOOST_CHECK(chainman->ProcessBlock(block, &new_block)); 910 BOOST_CHECK(!new_block); 911 } 912 913 BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests) 914 { 915 auto test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}}; 916 chainman_mainnet_validation_test(test_directory); 917 chainman_reindex_test(test_directory); 918 chainman_reindex_chainstate_test(test_directory); 919 } 920 921 BOOST_AUTO_TEST_CASE(btck_block_hash_tests) 922 { 923 std::array<std::byte, 32> test_hash; 924 std::array<std::byte, 32> test_hash_2; 925 for (int i = 0; i < 32; ++i) { 926 test_hash[i] = static_cast<std::byte>(i); 927 test_hash_2[i] = static_cast<std::byte>(i + 1); 928 } 929 BlockHash block_hash{test_hash}; 930 BlockHash block_hash_2{test_hash_2}; 931 BOOST_CHECK(block_hash != block_hash_2); 932 BOOST_CHECK(block_hash == block_hash); 933 CheckHandle(block_hash, block_hash_2); 934 } 935 936 BOOST_AUTO_TEST_CASE(btck_block_tree_entry_tests) 937 { 938 auto test_directory{TestDirectory{"block_tree_entry_test_bitcoin_kernel"}}; 939 auto notifications{std::make_shared<TestKernelNotifications>()}; 940 auto context{create_context(notifications, ChainType::REGTEST)}; 941 auto chainman{create_chainman( 942 test_directory, 943 /*reindex=*/false, 944 /*wipe_chainstate=*/false, 945 /*block_tree_db_in_memory=*/true, 946 /*chainstate_db_in_memory=*/true, 947 context)}; 948 949 // Process a couple of blocks 950 for (size_t i{0}; i < 3; i++) { 951 Block block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[i])}; 952 bool new_block{false}; 953 chainman->ProcessBlock(block, &new_block); 954 BOOST_CHECK(new_block); 955 } 956 957 auto chain{chainman->GetChain()}; 958 auto entry_0{chain.GetByHeight(0)}; 959 auto entry_1{chain.GetByHeight(1)}; 960 auto entry_2{chain.GetByHeight(2)}; 961 962 // Test inequality 963 BOOST_CHECK(entry_0 != entry_1); 964 BOOST_CHECK(entry_1 != entry_2); 965 BOOST_CHECK(entry_0 != entry_2); 966 967 // Test equality with same entry 968 BOOST_CHECK(entry_0 == chain.GetByHeight(0)); 969 BOOST_CHECK(entry_0 == BlockTreeEntry{entry_0}); 970 BOOST_CHECK(entry_1 == entry_1); 971 972 // Test GetPrevious 973 auto prev{entry_1.GetPrevious()}; 974 BOOST_CHECK(prev.has_value()); 975 BOOST_CHECK(prev.value() == entry_0); 976 } 977 978 BOOST_AUTO_TEST_CASE(btck_chainman_in_memory_tests) 979 { 980 auto in_memory_test_directory{TestDirectory{"in-memory_test_bitcoin_kernel"}}; 981 982 auto notifications{std::make_shared<TestKernelNotifications>()}; 983 auto context{create_context(notifications, ChainType::REGTEST)}; 984 auto chainman{create_chainman( 985 in_memory_test_directory, /*reindex=*/false, /*wipe_chainstate=*/false, 986 /*block_tree_db_in_memory=*/true, /*chainstate_db_in_memory=*/true, context)}; 987 988 for (auto& raw_block : REGTEST_BLOCK_DATA) { 989 Block block{hex_string_to_byte_vec(raw_block)}; 990 bool new_block{false}; 991 chainman->ProcessBlock(block, &new_block); 992 BOOST_CHECK(new_block); 993 } 994 995 BOOST_CHECK(std::filesystem::exists(in_memory_test_directory.m_directory / "blocks")); 996 BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "blocks" / "index")); 997 BOOST_CHECK(!std::filesystem::exists(in_memory_test_directory.m_directory / "chainstate")); 998 999 BOOST_CHECK(context.interrupt()); 1000 } 1001 1002 BOOST_AUTO_TEST_CASE(btck_chainman_regtest_tests) 1003 { 1004 auto test_directory{TestDirectory{"regtest_test_bitcoin_kernel"}}; 1005 1006 auto notifications{std::make_shared<TestKernelNotifications>()}; 1007 auto context{create_context(notifications, ChainType::REGTEST)}; 1008 1009 { 1010 auto chainman{create_chainman( 1011 test_directory, /*reindex=*/false, /*wipe_chainstate=*/false, 1012 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 1013 for (const auto& data : REGTEST_BLOCK_DATA) { 1014 Block block{hex_string_to_byte_vec(data)}; 1015 BlockHeader header = block.GetHeader(); 1016 BlockValidationState state{}; 1017 BOOST_CHECK(state.GetBlockValidationResult() == BlockValidationResult::UNSET); 1018 BOOST_CHECK(chainman->ProcessBlockHeader(header, state)); 1019 BOOST_CHECK(state.GetValidationMode() == ValidationMode::VALID); 1020 BlockTreeEntry entry{*chainman->GetBlockTreeEntry(header.Hash())}; 1021 BOOST_CHECK(!chainman->GetChain().Contains(entry)); 1022 BlockTreeEntry best_entry{chainman->GetBestEntry()}; 1023 BlockHash hash{entry.GetHash()}; 1024 BOOST_CHECK(hash == best_entry.GetHeader().Hash()); 1025 } 1026 } 1027 1028 // Validate 206 regtest blocks in total. 1029 // Stop halfway to check that it is possible to continue validating starting 1030 // from prior state. 1031 const size_t mid{REGTEST_BLOCK_DATA.size() / 2}; 1032 1033 { 1034 auto chainman{create_chainman( 1035 test_directory, /*reindex=*/false, /*wipe_chainstate=*/false, 1036 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 1037 for (size_t i{0}; i < mid; i++) { 1038 Block block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[i])}; 1039 bool new_block{false}; 1040 BOOST_CHECK(chainman->ProcessBlock(block, &new_block)); 1041 BOOST_CHECK(new_block); 1042 } 1043 } 1044 1045 auto chainman{create_chainman( 1046 test_directory, /*reindex=*/false, /*wipe_chainstate=*/false, 1047 /*block_tree_db_in_memory=*/false, /*chainstate_db_in_memory=*/false, context)}; 1048 1049 for (size_t i{mid}; i < REGTEST_BLOCK_DATA.size(); i++) { 1050 Block block{hex_string_to_byte_vec(REGTEST_BLOCK_DATA[i])}; 1051 bool new_block{false}; 1052 BOOST_CHECK(chainman->ProcessBlock(block, &new_block)); 1053 BOOST_CHECK(new_block); 1054 } 1055 1056 auto chain = chainman->GetChain(); 1057 auto tip = chain.Entries().back(); 1058 auto read_block = chainman->ReadBlock(tip).value(); 1059 check_equal(read_block.ToBytes(), hex_string_to_byte_vec(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 1])); 1060 1061 auto tip_2 = tip.GetPrevious().value(); 1062 auto read_block_2 = chainman->ReadBlock(tip_2).value(); 1063 check_equal(read_block_2.ToBytes(), hex_string_to_byte_vec(REGTEST_BLOCK_DATA[REGTEST_BLOCK_DATA.size() - 2])); 1064 1065 Txid txid = read_block.Transactions()[0].Txid(); 1066 Txid txid_2 = read_block_2.Transactions()[0].Txid(); 1067 BOOST_CHECK(txid != txid_2); 1068 BOOST_CHECK(txid == txid); 1069 CheckHandle(txid, txid_2); 1070 1071 auto find_transaction = [&chainman](const TxidView& target_txid) -> std::optional<Transaction> { 1072 auto chain = chainman->GetChain(); 1073 for (const auto block_tree_entry : chain.Entries()) { 1074 auto block{chainman->ReadBlock(block_tree_entry)}; 1075 for (const TransactionView transaction : block->Transactions()) { 1076 if (transaction.Txid() == target_txid) { 1077 return Transaction{transaction}; 1078 } 1079 } 1080 } 1081 return std::nullopt; 1082 }; 1083 1084 for (const auto block_tree_entry : chain.Entries()) { 1085 auto block{chainman->ReadBlock(block_tree_entry)}; 1086 for (const auto transaction : block->Transactions()) { 1087 std::vector<TransactionInput> inputs; 1088 std::vector<TransactionOutput> spent_outputs; 1089 for (const auto input : transaction.Inputs()) { 1090 OutPointView point = input.OutPoint(); 1091 if (point.index() == std::numeric_limits<uint32_t>::max()) { 1092 continue; 1093 } 1094 inputs.emplace_back(input); 1095 BOOST_CHECK(point.Txid() != transaction.Txid()); 1096 std::optional<Transaction> tx = find_transaction(point.Txid()); 1097 BOOST_CHECK(tx.has_value()); 1098 BOOST_CHECK(point.Txid() == tx->Txid()); 1099 spent_outputs.emplace_back(tx->GetOutput(point.index())); 1100 } 1101 BOOST_CHECK(inputs.size() == spent_outputs.size()); 1102 ScriptVerifyStatus status = ScriptVerifyStatus::OK; 1103 const PrecomputedTransactionData precomputed_txdata{transaction, spent_outputs}; 1104 for (size_t i{0}; i < inputs.size(); ++i) { 1105 BOOST_CHECK(spent_outputs[i].GetScriptPubkey().Verify(spent_outputs[i].Amount(), transaction, &precomputed_txdata, i, ScriptVerificationFlags::ALL, status)); 1106 } 1107 } 1108 } 1109 1110 // Read spent outputs for current tip and its previous block 1111 BlockSpentOutputs block_spent_outputs{chainman->ReadBlockSpentOutputs(tip)}; 1112 BlockSpentOutputs block_spent_outputs_prev{chainman->ReadBlockSpentOutputs(*tip.GetPrevious())}; 1113 CheckHandle(block_spent_outputs, block_spent_outputs_prev); 1114 CheckRange(block_spent_outputs_prev.TxsSpentOutputs(), block_spent_outputs_prev.Count()); 1115 BOOST_CHECK_EQUAL(block_spent_outputs.Count(), 1); 1116 1117 // Get transaction spent outputs from the last transaction in the two blocks 1118 TransactionSpentOutputsView transaction_spent_outputs{block_spent_outputs.GetTxSpentOutputs(block_spent_outputs.Count() - 1)}; 1119 TransactionSpentOutputs owned_transaction_spent_outputs{transaction_spent_outputs}; 1120 TransactionSpentOutputs owned_transaction_spent_outputs_prev{block_spent_outputs_prev.GetTxSpentOutputs(block_spent_outputs_prev.Count() - 1)}; 1121 CheckHandle(owned_transaction_spent_outputs, owned_transaction_spent_outputs_prev); 1122 CheckRange(transaction_spent_outputs.Coins(), transaction_spent_outputs.Count()); 1123 1124 // Get the last coin from the transaction spent outputs 1125 CoinView coin{transaction_spent_outputs.GetCoin(transaction_spent_outputs.Count() - 1)}; 1126 BOOST_CHECK(!coin.IsCoinbase()); 1127 Coin owned_coin{coin}; 1128 Coin owned_coin_prev{owned_transaction_spent_outputs_prev.GetCoin(owned_transaction_spent_outputs_prev.Count() - 1)}; 1129 CheckHandle(owned_coin, owned_coin_prev); 1130 1131 // Validate coin properties 1132 TransactionOutputView output = coin.GetOutput(); 1133 uint32_t coin_height = coin.GetConfirmationHeight(); 1134 BOOST_CHECK_EQUAL(coin_height, 205); 1135 BOOST_CHECK_EQUAL(output.Amount(), 100000000); 1136 1137 // Test script pubkey serialization 1138 auto script_pubkey = output.GetScriptPubkey(); 1139 auto script_pubkey_bytes{script_pubkey.ToBytes()}; 1140 BOOST_CHECK_EQUAL(script_pubkey_bytes.size(), 22); 1141 auto round_trip_script_pubkey{ScriptPubkey(script_pubkey_bytes)}; 1142 BOOST_CHECK_EQUAL(round_trip_script_pubkey.ToBytes().size(), 22); 1143 1144 for (const auto tx_spent_outputs : block_spent_outputs.TxsSpentOutputs()) { 1145 for (const auto coins : tx_spent_outputs.Coins()) { 1146 BOOST_CHECK_GT(coins.GetOutput().Amount(), 1); 1147 } 1148 } 1149 1150 CheckRange(chain.Entries(), chain.CountEntries()); 1151 1152 for (const BlockTreeEntry entry : chain.Entries()) { 1153 std::optional<Block> block{chainman->ReadBlock(entry)}; 1154 if (block) { 1155 for (const TransactionView transaction : block->Transactions()) { 1156 for (const TransactionOutputView output : transaction.Outputs()) { 1157 // skip data carrier outputs 1158 if ((unsigned char)output.GetScriptPubkey().ToBytes()[0] == 0x6a) { 1159 continue; 1160 } 1161 BOOST_CHECK_GT(output.Amount(), 1); 1162 } 1163 } 1164 } 1165 } 1166 1167 int32_t count{0}; 1168 for (const auto entry : chain.Entries()) { 1169 BOOST_CHECK_EQUAL(entry.GetHeight(), count); 1170 ++count; 1171 } 1172 BOOST_CHECK_EQUAL(count, chain.CountEntries()); 1173 1174 1175 std::filesystem::remove_all(test_directory.m_directory / "blocks" / "blk00000.dat"); 1176 BOOST_CHECK(!chainman->ReadBlock(tip_2).has_value()); 1177 std::filesystem::remove_all(test_directory.m_directory / "blocks" / "rev00000.dat"); 1178 BOOST_CHECK_THROW(chainman->ReadBlockSpentOutputs(tip), std::runtime_error); 1179 }