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