Branch data Line data Source code
1 : : // Copyright (c) 2022-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 : : #define BITCOINKERNEL_BUILD
6 : :
7 : : #include <kernel/bitcoinkernel.h>
8 : :
9 : : #include <chain.h>
10 : : #include <coins.h>
11 : : #include <consensus/validation.h>
12 : : #include <dbwrapper.h>
13 : : #include <kernel/caches.h>
14 : : #include <kernel/chainparams.h>
15 : : #include <kernel/checks.h>
16 : : #include <kernel/context.h>
17 : : #include <kernel/notifications_interface.h>
18 : : #include <kernel/warning.h>
19 : : #include <logging.h>
20 : : #include <node/blockstorage.h>
21 : : #include <node/chainstate.h>
22 : : #include <primitives/block.h>
23 : : #include <primitives/transaction.h>
24 : : #include <script/interpreter.h>
25 : : #include <script/script.h>
26 : : #include <serialize.h>
27 : : #include <streams.h>
28 : : #include <sync.h>
29 : : #include <uint256.h>
30 : : #include <undo.h>
31 : : #include <util/check.h>
32 : : #include <util/fs.h>
33 : : #include <util/result.h>
34 : : #include <util/signalinterrupt.h>
35 : : #include <util/task_runner.h>
36 : : #include <util/translation.h>
37 : : #include <validation.h>
38 : : #include <validationinterface.h>
39 : :
40 : : #include <cstddef>
41 : : #include <cstring>
42 : : #include <exception>
43 : : #include <functional>
44 : : #include <iterator>
45 : : #include <list>
46 : : #include <memory>
47 : : #include <span>
48 : : #include <stdexcept>
49 : : #include <string>
50 : : #include <tuple>
51 : : #include <utility>
52 : : #include <vector>
53 : :
54 : : using kernel::ChainstateRole;
55 : : using util::ImmediateTaskRunner;
56 : :
57 : : // Define G_TRANSLATION_FUN symbol in libbitcoinkernel library so users of the
58 : : // library aren't required to export this symbol
59 : : extern const std::function<std::string(const char*)> G_TRANSLATION_FUN{nullptr};
60 : :
61 : : static const kernel::Context btck_context_static{};
62 : :
63 : : namespace {
64 : :
65 : 47 : bool is_valid_flag_combination(script_verify_flags flags)
66 : : {
67 [ - + - - ]: 47 : if (flags & SCRIPT_VERIFY_CLEANSTACK && ~flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) return false;
68 [ + + - + ]: 47 : if (flags & SCRIPT_VERIFY_WITNESS && ~flags & SCRIPT_VERIFY_P2SH) return false;
69 : : return true;
70 : : }
71 : :
72 : : class WriterStream
73 : : {
74 : : private:
75 : : btck_WriteBytes m_writer;
76 : : void* m_user_data;
77 : :
78 : : public:
79 : 32 : WriterStream(btck_WriteBytes writer, void* user_data)
80 : 32 : : m_writer{writer}, m_user_data{user_data} {}
81 : :
82 : : //
83 : : // Stream subset
84 : : //
85 : 785 : void write(std::span<const std::byte> src)
86 : : {
87 [ - + ]: 785 : if (m_writer(std::data(src), src.size(), m_user_data) != 0) {
88 [ # # ]: 0 : throw std::runtime_error("Failed to write serialization data");
89 : : }
90 : 785 : }
91 : :
92 : : template <typename T>
93 : 32 : WriterStream& operator<<(const T& obj)
94 : : {
95 [ + - + - ]: 32 : ::Serialize(*this, obj);
96 : 32 : return *this;
97 : : }
98 : : };
99 : :
100 : : template <typename C, typename CPP>
101 : : struct Handle {
102 : : static C* ref(CPP* cpp_type)
103 : : {
104 : : return reinterpret_cast<C*>(cpp_type);
105 : : }
106 : :
107 : : static const C* ref(const CPP* cpp_type)
108 : : {
109 : : return reinterpret_cast<const C*>(cpp_type);
110 : : }
111 : :
112 : : template <typename... Args>
113 : 4776 : static C* create(Args&&... args)
114 : : {
115 : 4776 : auto cpp_obj{std::make_unique<CPP>(std::forward<Args>(args)...)};
116 : 9552 : return reinterpret_cast<C*>(cpp_obj.release());
117 : 4776 : }
118 : :
119 : 643 : static C* copy(const C* ptr)
120 : : {
121 : 643 : auto cpp_obj{std::make_unique<CPP>(get(ptr))};
122 : 1286 : return reinterpret_cast<C*>(cpp_obj.release());
123 : 643 : }
124 : :
125 : : static const CPP& get(const C* ptr)
126 : : {
127 : : return *reinterpret_cast<const CPP*>(ptr);
128 : : }
129 : :
130 : : static CPP& get(C* ptr)
131 : : {
132 : : return *reinterpret_cast<CPP*>(ptr);
133 : : }
134 : :
135 : 5431 : static void operator delete(void* ptr)
136 : : {
137 [ + - ]: 9742 : delete reinterpret_cast<CPP*>(ptr);
138 : 5431 : }
139 : : };
140 : :
141 : : } // namespace
142 : :
143 : : struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};
144 : : struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};
145 : : struct btck_BlockValidationState : Handle<btck_BlockValidationState, BlockValidationState> {};
146 : :
147 : : namespace {
148 : :
149 : 2 : BCLog::Level get_bclog_level(btck_LogLevel level)
150 : : {
151 [ - + - - ]: 2 : switch (level) {
152 : : case btck_LogLevel_INFO: {
153 : : return BCLog::Level::Info;
154 : : }
155 : 0 : case btck_LogLevel_DEBUG: {
156 : 0 : return BCLog::Level::Debug;
157 : : }
158 : 2 : case btck_LogLevel_TRACE: {
159 : 2 : return BCLog::Level::Trace;
160 : : }
161 : : }
162 : 0 : assert(false);
163 : : }
164 : :
165 : 6 : BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
166 : : {
167 [ - - - - : 6 : switch (category) {
- - - + +
- - + ]
168 : : case btck_LogCategory_BENCH: {
169 : : return BCLog::LogFlags::BENCH;
170 : : }
171 : 0 : case btck_LogCategory_BLOCKSTORAGE: {
172 : 0 : return BCLog::LogFlags::BLOCKSTORAGE;
173 : : }
174 : 0 : case btck_LogCategory_COINDB: {
175 : 0 : return BCLog::LogFlags::COINDB;
176 : : }
177 : 0 : case btck_LogCategory_LEVELDB: {
178 : 0 : return BCLog::LogFlags::LEVELDB;
179 : : }
180 : 0 : case btck_LogCategory_MEMPOOL: {
181 : 0 : return BCLog::LogFlags::MEMPOOL;
182 : : }
183 : 0 : case btck_LogCategory_PRUNE: {
184 : 0 : return BCLog::LogFlags::PRUNE;
185 : : }
186 : 0 : case btck_LogCategory_RAND: {
187 : 0 : return BCLog::LogFlags::RAND;
188 : : }
189 : 0 : case btck_LogCategory_REINDEX: {
190 : 0 : return BCLog::LogFlags::REINDEX;
191 : : }
192 : 2 : case btck_LogCategory_VALIDATION: {
193 : 2 : return BCLog::LogFlags::VALIDATION;
194 : : }
195 : 2 : case btck_LogCategory_KERNEL: {
196 : 2 : return BCLog::LogFlags::KERNEL;
197 : : }
198 : 0 : case btck_LogCategory_ALL: {
199 : 0 : return BCLog::LogFlags::ALL;
200 : : }
201 : : }
202 : 0 : assert(false);
203 : : }
204 : :
205 : 847 : btck_SynchronizationState cast_state(SynchronizationState state)
206 : : {
207 [ + - - + ]: 847 : switch (state) {
208 : : case SynchronizationState::INIT_REINDEX:
209 : : return btck_SynchronizationState_INIT_REINDEX;
210 : 844 : case SynchronizationState::INIT_DOWNLOAD:
211 : 844 : return btck_SynchronizationState_INIT_DOWNLOAD;
212 : 0 : case SynchronizationState::POST_INIT:
213 : 0 : return btck_SynchronizationState_POST_INIT;
214 : : } // no default case, so the compiler can warn about missing cases
215 : 0 : assert(false);
216 : : }
217 : :
218 : 427 : btck_Warning cast_btck_warning(kernel::Warning warning)
219 : : {
220 [ + - - ]: 427 : switch (warning) {
221 : : case kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED:
222 : : return btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED;
223 : 427 : case kernel::Warning::LARGE_WORK_INVALID_CHAIN:
224 : 427 : return btck_Warning_LARGE_WORK_INVALID_CHAIN;
225 : : } // no default case, so the compiler can warn about missing cases
226 : 0 : assert(false);
227 : : }
228 : :
229 : : struct LoggingConnection {
230 : : std::unique_ptr<std::list<std::function<void(const std::string&)>>::iterator> m_connection;
231 : : void* m_user_data;
232 : : std::function<void(void* user_data)> m_deleter;
233 : :
234 : 4 : LoggingConnection(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
235 [ + - ]: 4 : {
236 [ + - ]: 4 : LOCK(cs_main);
237 : :
238 [ - + + - : 78 : auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback(user_data, str.c_str(), str.length()); })};
+ - ]
239 : :
240 : : // Only start logging if we just added the connection.
241 [ + - + - : 4 : if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {
+ + + - +
- - + ]
242 [ # # ]: 0 : LogError("Logger start failed.");
243 [ # # # # ]: 0 : LogInstance().DeleteCallback(connection);
244 [ # # # # ]: 0 : if (user_data && user_data_destroy_callback) {
245 [ # # ]: 0 : user_data_destroy_callback(user_data);
246 : : }
247 [ # # ]: 0 : throw std::runtime_error("Failed to start logging");
248 : : }
249 : :
250 [ + - ]: 4 : m_connection = std::make_unique<std::list<std::function<void(const std::string&)>>::iterator>(connection);
251 : 4 : m_user_data = user_data;
252 : 4 : m_deleter = user_data_destroy_callback;
253 : :
254 [ + - + - : 4 : LogDebug(BCLog::KERNEL, "Logger connected.");
+ - + - ]
255 : 4 : }
256 : :
257 : 4 : ~LoggingConnection()
258 : : {
259 : 4 : LOCK(cs_main);
260 [ + - ]: 4 : LogDebug(BCLog::KERNEL, "Logger disconnecting.");
261 : :
262 : : // Switch back to buffering by calling DisconnectTestLogger if the
263 : : // connection that we are about to remove is the last one.
264 [ + + ]: 4 : if (LogInstance().NumConnections() == 1) {
265 : 3 : LogInstance().DisconnectTestLogger();
266 : : } else {
267 : 1 : LogInstance().DeleteCallback(*m_connection);
268 : : }
269 : :
270 [ + - ]: 4 : m_connection.reset();
271 [ + - + - ]: 4 : if (m_user_data && m_deleter) {
272 : 4 : m_deleter(m_user_data);
273 : : }
274 : 4 : }
275 : : };
276 : :
277 : : class KernelNotifications final : public kernel::Notifications
278 : : {
279 : : private:
280 : : btck_NotificationInterfaceCallbacks m_cbs;
281 : :
282 : : public:
283 : 14 : KernelNotifications(btck_NotificationInterfaceCallbacks cbs)
284 : 14 : : m_cbs{cbs}
285 : : {
286 : : }
287 : :
288 : 14 : ~KernelNotifications()
289 : 14 : {
290 [ + + + - ]: 14 : if (m_cbs.user_data && m_cbs.user_data_destroy) {
291 : 8 : m_cbs.user_data_destroy(m_cbs.user_data);
292 : : }
293 : 14 : m_cbs.user_data_destroy = nullptr;
294 : 14 : m_cbs.user_data = nullptr;
295 : 14 : }
296 : :
297 : 429 : kernel::InterruptResult blockTip(SynchronizationState state, const CBlockIndex& index, double verification_progress) override
298 : : {
299 [ + + ]: 429 : if (m_cbs.block_tip) m_cbs.block_tip(m_cbs.user_data, cast_state(state), btck_BlockTreeEntry::ref(&index), verification_progress);
300 : 429 : return {};
301 : : }
302 : 420 : void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override
303 : : {
304 [ + - + - ]: 840 : if (m_cbs.header_tip) m_cbs.header_tip(m_cbs.user_data, cast_state(state), height, timestamp, presync ? 1 : 0);
305 : 420 : }
306 : 15 : void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
307 : : {
308 [ + + + - : 28 : if (m_cbs.progress) m_cbs.progress(m_cbs.user_data, title.original.c_str(), title.original.length(), progress_percent, resume_possible ? 1 : 0);
- + ]
309 : 15 : }
310 : 0 : void warningSet(kernel::Warning id, const bilingual_str& message) override
311 : : {
312 [ # # # # ]: 0 : if (m_cbs.warning_set) m_cbs.warning_set(m_cbs.user_data, cast_btck_warning(id), message.original.c_str(), message.original.length());
313 : 0 : }
314 : 429 : void warningUnset(kernel::Warning id) override
315 : : {
316 [ + + ]: 429 : if (m_cbs.warning_unset) m_cbs.warning_unset(m_cbs.user_data, cast_btck_warning(id));
317 : 429 : }
318 : 0 : void flushError(const bilingual_str& message) override
319 : : {
320 [ # # # # ]: 0 : if (m_cbs.flush_error) m_cbs.flush_error(m_cbs.user_data, message.original.c_str(), message.original.length());
321 : 0 : }
322 : 0 : void fatalError(const bilingual_str& message) override
323 : : {
324 [ # # # # ]: 0 : if (m_cbs.fatal_error) m_cbs.fatal_error(m_cbs.user_data, message.original.c_str(), message.original.length());
325 : 0 : }
326 : : };
327 : :
328 : : class KernelValidationInterface final : public CValidationInterface
329 : : {
330 : : public:
331 : : btck_ValidationInterfaceCallbacks m_cbs;
332 : :
333 : 1 : explicit KernelValidationInterface(const btck_ValidationInterfaceCallbacks vi_cbs) : m_cbs{vi_cbs} {}
334 : :
335 : 1 : ~KernelValidationInterface()
336 : 1 : {
337 [ + - + - ]: 1 : if (m_cbs.user_data && m_cbs.user_data_destroy) {
338 : 1 : m_cbs.user_data_destroy(m_cbs.user_data);
339 : : }
340 : 1 : m_cbs.user_data = nullptr;
341 : 1 : m_cbs.user_data_destroy = nullptr;
342 : 1 : }
343 : :
344 : : protected:
345 : 3 : void BlockChecked(const std::shared_ptr<const CBlock>& block, const BlockValidationState& stateIn) override
346 : : {
347 [ + - ]: 3 : if (m_cbs.block_checked) {
348 : 3 : m_cbs.block_checked(m_cbs.user_data,
349 : : btck_Block::copy(btck_Block::ref(&block)),
350 : : btck_BlockValidationState::ref(&stateIn));
351 : : }
352 : 3 : }
353 : :
354 : 0 : void NewPoWValidBlock(const CBlockIndex* pindex, const std::shared_ptr<const CBlock>& block) override
355 : : {
356 [ # # ]: 0 : if (m_cbs.pow_valid_block) {
357 : 0 : m_cbs.pow_valid_block(m_cbs.user_data,
358 : : btck_Block::copy(btck_Block::ref(&block)),
359 : : btck_BlockTreeEntry::ref(pindex));
360 : : }
361 : 0 : }
362 : :
363 : 2 : void BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
364 : : {
365 [ + - ]: 2 : if (m_cbs.block_connected) {
366 : 2 : m_cbs.block_connected(m_cbs.user_data,
367 : : btck_Block::copy(btck_Block::ref(&block)),
368 : : btck_BlockTreeEntry::ref(pindex));
369 : : }
370 : 2 : }
371 : :
372 : 0 : void BlockDisconnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex) override
373 : : {
374 [ # # ]: 0 : if (m_cbs.block_disconnected) {
375 : 0 : m_cbs.block_disconnected(m_cbs.user_data,
376 : : btck_Block::copy(btck_Block::ref(&block)),
377 : : btck_BlockTreeEntry::ref(pindex));
378 : : }
379 : 0 : }
380 : : };
381 : :
382 : 14 : struct ContextOptions {
383 : : mutable Mutex m_mutex;
384 : : std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
385 : : std::shared_ptr<KernelNotifications> m_notifications GUARDED_BY(m_mutex);
386 : : std::shared_ptr<KernelValidationInterface> m_validation_interface GUARDED_BY(m_mutex);
387 : : };
388 : :
389 : : class Context
390 : : {
391 : : public:
392 : : std::unique_ptr<kernel::Context> m_context;
393 : :
394 : : std::shared_ptr<KernelNotifications> m_notifications;
395 : :
396 : : std::unique_ptr<util::SignalInterrupt> m_interrupt;
397 : :
398 : : std::unique_ptr<ValidationSignals> m_signals;
399 : :
400 : : std::unique_ptr<const CChainParams> m_chainparams;
401 : :
402 : : std::shared_ptr<KernelValidationInterface> m_validation_interface;
403 : :
404 : 14 : Context(const ContextOptions* options, bool& sane)
405 : 14 : : m_context{std::make_unique<kernel::Context>()},
406 [ + - + - ]: 14 : m_interrupt{std::make_unique<util::SignalInterrupt>()}
407 : : {
408 [ + - ]: 14 : if (options) {
409 [ + - ]: 14 : LOCK(options->m_mutex);
410 [ + + ]: 14 : if (options->m_chainparams) {
411 [ + - ]: 8 : m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
412 : : }
413 [ + + ]: 14 : if (options->m_notifications) {
414 : 8 : m_notifications = options->m_notifications;
415 : : }
416 [ + + ]: 14 : if (options->m_validation_interface) {
417 [ + - + - ]: 1 : m_signals = std::make_unique<ValidationSignals>(std::make_unique<ImmediateTaskRunner>());
418 : 1 : m_validation_interface = options->m_validation_interface;
419 [ + - + - ]: 3 : m_signals->RegisterSharedValidationInterface(m_validation_interface);
420 : : }
421 : 14 : }
422 : :
423 [ + + ]: 14 : if (!m_chainparams) {
424 [ + - ]: 6 : m_chainparams = CChainParams::Main();
425 : : }
426 [ + + ]: 14 : if (!m_notifications) {
427 [ + - ]: 12 : m_notifications = std::make_shared<KernelNotifications>(btck_NotificationInterfaceCallbacks{
428 [ - + ]: 6 : nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr});
429 : : }
430 : :
431 [ + - - + ]: 14 : if (!kernel::SanityChecks(*m_context)) {
432 : 0 : sane = false;
433 : : }
434 [ - - - - ]: 14 : }
435 : :
436 : 14 : ~Context()
437 : : {
438 [ + + ]: 14 : if (m_signals) {
439 [ + - + - ]: 3 : m_signals->UnregisterSharedValidationInterface(m_validation_interface);
440 : : }
441 [ + + + - ]: 29 : }
442 : : };
443 : :
444 : : //! Helper struct to wrap the ChainstateManager-related Options
445 : : struct ChainstateManagerOptions {
446 : : mutable Mutex m_mutex;
447 : : ChainstateManager::Options m_chainman_options GUARDED_BY(m_mutex);
448 : : node::BlockManager::Options m_blockman_options GUARDED_BY(m_mutex);
449 : : std::shared_ptr<const Context> m_context;
450 : : node::ChainstateLoadOptions m_chainstate_load_options GUARDED_BY(m_mutex);
451 : :
452 : 11 : ChainstateManagerOptions(const std::shared_ptr<const Context>& context, const fs::path& data_dir, const fs::path& blocks_dir)
453 [ + - ]: 11 : : m_chainman_options{ChainstateManager::Options{
454 : 11 : .chainparams = *context->m_chainparams,
455 : : .datadir = data_dir,
456 [ + - ]: 11 : .notifications = *context->m_notifications,
457 [ + - ]: 11 : .signals = context->m_signals.get()}},
458 [ + - ]: 22 : m_blockman_options{node::BlockManager::Options{
459 [ + - ]: 11 : .chainparams = *context->m_chainparams,
460 : : .blocks_dir = blocks_dir,
461 [ + - ]: 11 : .notifications = *context->m_notifications,
462 : : .block_tree_db_params = DBParams{
463 [ + - + - ]: 33 : .path = data_dir / "blocks" / "index",
464 : 11 : .cache_bytes = kernel::CacheSizes{DEFAULT_KERNEL_CACHE}.block_tree_db,
465 : : }}},
466 [ + - ]: 33 : m_context{context}, m_chainstate_load_options{node::ChainstateLoadOptions{}}
467 : : {
468 : 11 : }
469 : : };
470 : :
471 : : struct ChainMan {
472 : : std::unique_ptr<ChainstateManager> m_chainman;
473 : : std::shared_ptr<const Context> m_context;
474 : :
475 : 11 : ChainMan(std::unique_ptr<ChainstateManager> chainman, std::shared_ptr<const Context> context)
476 : 11 : : m_chainman(std::move(chainman)), m_context(std::move(context)) {}
477 : : };
478 : :
479 : : } // namespace
480 : :
481 : : struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};
482 : : struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};
483 : : struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};
484 : : struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};
485 : : struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};
486 : : struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
487 : : struct btck_ChainParameters : Handle<btck_ChainParameters, CChainParams> {};
488 : : struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};
489 : : struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};
490 : : struct btck_Chain : Handle<btck_Chain, CChain> {};
491 : : struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<CBlockUndo>> {};
492 : : struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};
493 : : struct btck_Coin : Handle<btck_Coin, Coin> {};
494 : : struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};
495 : : struct btck_TransactionInput : Handle<btck_TransactionInput, CTxIn> {};
496 : : struct btck_TransactionOutPoint: Handle<btck_TransactionOutPoint, COutPoint> {};
497 : : struct btck_Txid: Handle<btck_Txid, Txid> {};
498 : : struct btck_PrecomputedTransactionData : Handle<btck_PrecomputedTransactionData, PrecomputedTransactionData> {};
499 : : struct btck_BlockHeader: Handle<btck_BlockHeader, CBlockHeader> {};
500 : :
501 : 14 : btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
502 : : {
503 [ + - ]: 14 : if (raw_transaction == nullptr && raw_transaction_len != 0) {
504 : : return nullptr;
505 : : }
506 : 14 : try {
507 [ + - ]: 14 : DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_transaction), raw_transaction_len}};
508 [ + + + - : 14 : return btck_Transaction::create(std::make_shared<const CTransaction>(deserialize, TX_WITH_WITNESS, stream));
- + ]
509 : 14 : } catch (...) {
510 : 3 : return nullptr;
511 : 3 : }
512 : : }
513 : :
514 : 260 : size_t btck_transaction_count_outputs(const btck_Transaction* transaction)
515 : : {
516 [ - + ]: 260 : return btck_Transaction::get(transaction)->vout.size();
517 : : }
518 : :
519 : 511 : const btck_TransactionOutput* btck_transaction_get_output_at(const btck_Transaction* transaction, size_t output_index)
520 : : {
521 [ - + ]: 511 : const CTransaction& tx = *btck_Transaction::get(transaction);
522 [ - + - + ]: 511 : assert(output_index < tx.vout.size());
523 : 511 : return btck_TransactionOutput::ref(&tx.vout[output_index]);
524 : : }
525 : :
526 : 257 : size_t btck_transaction_count_inputs(const btck_Transaction* transaction)
527 : : {
528 [ - + ]: 257 : return btck_Transaction::get(transaction)->vin.size();
529 : : }
530 : :
531 : 249 : const btck_TransactionInput* btck_transaction_get_input_at(const btck_Transaction* transaction, size_t input_index)
532 : : {
533 [ - + - + ]: 249 : assert(input_index < btck_Transaction::get(transaction)->vin.size());
534 : 249 : return btck_TransactionInput::ref(&btck_Transaction::get(transaction)->vin[input_index]);
535 : : }
536 : :
537 : 2500 : const btck_Txid* btck_transaction_get_txid(const btck_Transaction* transaction)
538 : : {
539 : 2500 : return btck_Txid::ref(&btck_Transaction::get(transaction)->GetHash());
540 : : }
541 : :
542 : 290 : btck_Transaction* btck_transaction_copy(const btck_Transaction* transaction)
543 : : {
544 : 290 : return btck_Transaction::copy(transaction);
545 : : }
546 : :
547 : 12 : int btck_transaction_to_bytes(const btck_Transaction* transaction, btck_WriteBytes writer, void* user_data)
548 : : {
549 : 12 : try {
550 : 12 : WriterStream ws{writer, user_data};
551 [ + - ]: 24 : ws << TX_WITH_WITNESS(btck_Transaction::get(transaction));
552 : : return 0;
553 : 0 : } catch (...) {
554 : 0 : return -1;
555 : 0 : }
556 : : }
557 : :
558 : 329 : void btck_transaction_destroy(btck_Transaction* transaction)
559 : : {
560 [ + + ]: 329 : delete transaction;
561 : 329 : }
562 : :
563 : 11 : btck_ScriptPubkey* btck_script_pubkey_create(const void* script_pubkey, size_t script_pubkey_len)
564 : : {
565 [ + - ]: 11 : if (script_pubkey == nullptr && script_pubkey_len != 0) {
566 : : return nullptr;
567 : : }
568 : 11 : auto data = std::span{reinterpret_cast<const uint8_t*>(script_pubkey), script_pubkey_len};
569 : 11 : return btck_ScriptPubkey::create(data.begin(), data.end());
570 : : }
571 : :
572 : 492 : int btck_script_pubkey_to_bytes(const btck_ScriptPubkey* script_pubkey_, btck_WriteBytes writer, void* user_data)
573 : : {
574 : 492 : const auto& script_pubkey{btck_ScriptPubkey::get(script_pubkey_)};
575 [ + + + + ]: 1191 : return writer(script_pubkey.data(), script_pubkey.size(), user_data);
576 : : }
577 : :
578 : 12 : btck_ScriptPubkey* btck_script_pubkey_copy(const btck_ScriptPubkey* script_pubkey)
579 : : {
580 : 12 : return btck_ScriptPubkey::copy(script_pubkey);
581 : : }
582 : :
583 : 27 : void btck_script_pubkey_destroy(btck_ScriptPubkey* script_pubkey)
584 : : {
585 [ + + ]: 27 : delete script_pubkey;
586 : 27 : }
587 : :
588 : 5 : btck_TransactionOutput* btck_transaction_output_create(const btck_ScriptPubkey* script_pubkey, int64_t amount)
589 : : {
590 : 5 : return btck_TransactionOutput::create(amount, btck_ScriptPubkey::get(script_pubkey));
591 : : }
592 : :
593 : 33 : btck_TransactionOutput* btck_transaction_output_copy(const btck_TransactionOutput* output)
594 : : {
595 : 33 : return btck_TransactionOutput::copy(output);
596 : : }
597 : :
598 : 493 : const btck_ScriptPubkey* btck_transaction_output_get_script_pubkey(const btck_TransactionOutput* output)
599 : : {
600 : 493 : return btck_ScriptPubkey::ref(&btck_TransactionOutput::get(output).scriptPubKey);
601 : : }
602 : :
603 : 297 : int64_t btck_transaction_output_get_amount(const btck_TransactionOutput* output)
604 : : {
605 : 297 : return btck_TransactionOutput::get(output).nValue;
606 : : }
607 : :
608 : 42 : void btck_transaction_output_destroy(btck_TransactionOutput* output)
609 : : {
610 [ + + ]: 42 : delete output;
611 : 42 : }
612 : :
613 : 238 : btck_PrecomputedTransactionData* btck_precomputed_transaction_data_create(
614 : : const btck_Transaction* tx_to,
615 : : const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len)
616 : : {
617 : 238 : try {
618 [ + - ]: 238 : const CTransaction& tx{*btck_Transaction::get(tx_to)};
619 [ + - ]: 238 : auto txdata{btck_PrecomputedTransactionData::create()};
620 [ + + ]: 238 : if (spent_outputs_ != nullptr && spent_outputs_len > 0) {
621 [ - + - + ]: 27 : assert(spent_outputs_len == tx.vin.size());
622 : 27 : std::vector<CTxOut> spent_outputs;
623 [ + - ]: 27 : spent_outputs.reserve(spent_outputs_len);
624 [ + + ]: 56 : for (size_t i = 0; i < spent_outputs_len; i++) {
625 : 29 : const CTxOut& tx_out{btck_TransactionOutput::get(spent_outputs_[i])};
626 [ + - ]: 29 : spent_outputs.push_back(tx_out);
627 : : }
628 [ + - ]: 27 : btck_PrecomputedTransactionData::get(txdata).Init(tx, std::move(spent_outputs));
629 : 27 : } else {
630 [ + - ]: 211 : btck_PrecomputedTransactionData::get(txdata).Init(tx, {});
631 : : }
632 : :
633 : : return txdata;
634 : 0 : } catch (...) {
635 : 0 : return nullptr;
636 : 0 : }
637 : : }
638 : :
639 : 5 : btck_PrecomputedTransactionData* btck_precomputed_transaction_data_copy(const btck_PrecomputedTransactionData* precomputed_txdata)
640 : : {
641 : 5 : return btck_PrecomputedTransactionData::copy(precomputed_txdata);
642 : : }
643 : :
644 : 245 : void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData* precomputed_txdata)
645 : : {
646 [ + + ]: 245 : delete precomputed_txdata;
647 : 245 : }
648 : :
649 : 47 : int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
650 : : const int64_t amount,
651 : : const btck_Transaction* tx_to,
652 : : const btck_PrecomputedTransactionData* precomputed_txdata,
653 : : const unsigned int input_index,
654 : : const btck_ScriptVerificationFlags flags,
655 : : btck_ScriptVerifyStatus* status)
656 : : {
657 : : // Assert that all specified flags are part of the interface before continuing
658 [ - + ]: 47 : assert((flags & ~btck_ScriptVerificationFlags_ALL) == 0);
659 : :
660 [ - + ]: 47 : if (!is_valid_flag_combination(script_verify_flags::from_int(flags))) {
661 [ # # ]: 0 : if (status) *status = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION;
662 : 0 : return 0;
663 : : }
664 : :
665 [ - + ]: 47 : const CTransaction& tx{*btck_Transaction::get(tx_to)};
666 [ - + - + ]: 47 : assert(input_index < tx.vin.size());
667 : :
668 [ + + ]: 47 : const PrecomputedTransactionData& txdata{precomputed_txdata ? btck_PrecomputedTransactionData::get(precomputed_txdata) : PrecomputedTransactionData(tx)};
669 : :
670 [ + + + + ]: 47 : if (flags & btck_ScriptVerificationFlags_TAPROOT && txdata.m_spent_outputs.empty()) {
671 [ + - ]: 4 : if (status) *status = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED;
672 : 4 : return 0;
673 : : }
674 : :
675 [ + - ]: 43 : if (status) *status = btck_ScriptVerifyStatus_OK;
676 : :
677 [ + - ]: 43 : bool result = VerifyScript(tx.vin[input_index].scriptSig,
678 : : btck_ScriptPubkey::get(script_pubkey),
679 [ + - ]: 43 : &tx.vin[input_index].scriptWitness,
680 : : script_verify_flags::from_int(flags),
681 [ + - ]: 43 : TransactionSignatureChecker(&tx, input_index, amount, txdata, MissingDataBehavior::FAIL),
682 : : nullptr);
683 [ - + ]: 43 : return result ? 1 : 0;
684 : 47 : }
685 : :
686 : 33 : btck_TransactionInput* btck_transaction_input_copy(const btck_TransactionInput* input)
687 : : {
688 : 33 : return btck_TransactionInput::copy(input);
689 : : }
690 : :
691 : 235 : const btck_TransactionOutPoint* btck_transaction_input_get_out_point(const btck_TransactionInput* input)
692 : : {
693 : 235 : return btck_TransactionOutPoint::ref(&btck_TransactionInput::get(input).prevout);
694 : : }
695 : :
696 : 36 : void btck_transaction_input_destroy(btck_TransactionInput* input)
697 : : {
698 [ + + ]: 36 : delete input;
699 : 36 : }
700 : :
701 : 7 : btck_TransactionOutPoint* btck_transaction_out_point_copy(const btck_TransactionOutPoint* out_point)
702 : : {
703 : 7 : return btck_TransactionOutPoint::copy(out_point);
704 : : }
705 : :
706 : 259 : uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint* out_point)
707 : : {
708 : 259 : return btck_TransactionOutPoint::get(out_point).n;
709 : : }
710 : :
711 : 78 : const btck_Txid* btck_transaction_out_point_get_txid(const btck_TransactionOutPoint* out_point)
712 : : {
713 : 78 : return btck_Txid::ref(&btck_TransactionOutPoint::get(out_point).hash);
714 : : }
715 : :
716 : 9 : void btck_transaction_out_point_destroy(btck_TransactionOutPoint* out_point)
717 : : {
718 [ + + ]: 9 : delete out_point;
719 : 9 : }
720 : :
721 : 7 : btck_Txid* btck_txid_copy(const btck_Txid* txid)
722 : : {
723 : 7 : return btck_Txid::copy(txid);
724 : : }
725 : :
726 : 1 : void btck_txid_to_bytes(const btck_Txid* txid, unsigned char output[32])
727 : : {
728 : 1 : std::memcpy(output, btck_Txid::get(txid).begin(), 32);
729 : 1 : }
730 : :
731 : 2499 : int btck_txid_equals(const btck_Txid* txid1, const btck_Txid* txid2)
732 : : {
733 : 2499 : return btck_Txid::get(txid1) == btck_Txid::get(txid2);
734 : : }
735 : :
736 : 9 : void btck_txid_destroy(btck_Txid* txid)
737 : : {
738 [ + + ]: 9 : delete txid;
739 : 9 : }
740 : :
741 : 1 : void btck_logging_set_options(const btck_LoggingOptions options)
742 : : {
743 : 1 : LOCK(cs_main);
744 [ + - ]: 1 : LogInstance().m_log_timestamps = options.log_timestamps;
745 [ + - ]: 1 : LogInstance().m_log_time_micros = options.log_time_micros;
746 [ + - ]: 1 : LogInstance().m_log_threadnames = options.log_threadnames;
747 [ + - ]: 1 : LogInstance().m_log_sourcelocations = options.log_sourcelocations;
748 [ + - + - ]: 1 : LogInstance().m_always_print_category_level = options.always_print_category_levels;
749 : 1 : }
750 : :
751 : 2 : void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
752 : : {
753 : 2 : LOCK(cs_main);
754 [ - + ]: 2 : if (category == btck_LogCategory_ALL) {
755 [ # # ]: 0 : LogInstance().SetLogLevel(get_bclog_level(level));
756 : : }
757 : :
758 [ + - + - ]: 2 : LogInstance().AddCategoryLogLevel(get_bclog_flag(category), get_bclog_level(level));
759 : 2 : }
760 : :
761 : 2 : void btck_logging_enable_category(btck_LogCategory category)
762 : : {
763 : 2 : LogInstance().EnableCategory(get_bclog_flag(category));
764 : 2 : }
765 : :
766 : 2 : void btck_logging_disable_category(btck_LogCategory category)
767 : : {
768 : 2 : LogInstance().DisableCategory(get_bclog_flag(category));
769 : 2 : }
770 : :
771 : 0 : void btck_logging_disable()
772 : : {
773 : 0 : LogInstance().DisableLogging();
774 : 0 : }
775 : :
776 : 4 : btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
777 : : {
778 : 4 : try {
779 [ + - ]: 4 : return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback);
780 [ - - ]: 0 : } catch (const std::exception&) {
781 : 0 : return nullptr;
782 : 0 : }
783 : : }
784 : :
785 : 4 : void btck_logging_connection_destroy(btck_LoggingConnection* connection)
786 : : {
787 [ + - ]: 4 : delete connection;
788 : 4 : }
789 : :
790 : 9 : btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)
791 : : {
792 [ + - - - : 9 : switch (chain_type) {
+ - ]
793 : 5 : case btck_ChainType_MAINNET: {
794 : 5 : return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::Main().release()));
795 : : }
796 : 0 : case btck_ChainType_TESTNET: {
797 : 0 : return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet().release()));
798 : : }
799 : 0 : case btck_ChainType_TESTNET_4: {
800 : 0 : return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet4().release()));
801 : : }
802 : 0 : case btck_ChainType_SIGNET: {
803 [ # # ]: 0 : return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::SigNet({}).release()));
804 : : }
805 : 4 : case btck_ChainType_REGTEST: {
806 : 8 : return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::RegTest({}).release()));
807 : : }
808 : : }
809 : 0 : assert(false);
810 [ + - ]: 4 : }
811 : :
812 : 5 : btck_ChainParameters* btck_chain_parameters_copy(const btck_ChainParameters* chain_parameters)
813 : : {
814 : 5 : return btck_ChainParameters::copy(chain_parameters);
815 : : }
816 : :
817 : 16 : void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters)
818 : : {
819 [ + + ]: 16 : delete chain_parameters;
820 : 16 : }
821 : :
822 : 14 : btck_ContextOptions* btck_context_options_create()
823 : : {
824 : 14 : return btck_ContextOptions::create();
825 : : }
826 : :
827 : 8 : void btck_context_options_set_chainparams(btck_ContextOptions* options, const btck_ChainParameters* chain_parameters)
828 : : {
829 : : // Copy the chainparams, so the caller can free it again
830 : 8 : LOCK(btck_ContextOptions::get(options).m_mutex);
831 [ + - + - ]: 8 : btck_ContextOptions::get(options).m_chainparams = std::make_unique<const CChainParams>(btck_ChainParameters::get(chain_parameters));
832 : 8 : }
833 : :
834 : 8 : void btck_context_options_set_notifications(btck_ContextOptions* options, btck_NotificationInterfaceCallbacks notifications)
835 : : {
836 : : // The KernelNotifications are copy-initialized, so the caller can free them again.
837 : 8 : LOCK(btck_ContextOptions::get(options).m_mutex);
838 [ + - - + : 8 : btck_ContextOptions::get(options).m_notifications = std::make_shared<KernelNotifications>(notifications);
+ - ]
839 : 8 : }
840 : :
841 : 1 : void btck_context_options_set_validation_interface(btck_ContextOptions* options, btck_ValidationInterfaceCallbacks vi_cbs)
842 : : {
843 : 1 : LOCK(btck_ContextOptions::get(options).m_mutex);
844 [ + - - + : 1 : btck_ContextOptions::get(options).m_validation_interface = std::make_shared<KernelValidationInterface>(vi_cbs);
+ - ]
845 : 1 : }
846 : :
847 : 14 : void btck_context_options_destroy(btck_ContextOptions* options)
848 : : {
849 [ + - ]: 14 : delete options;
850 : 14 : }
851 : :
852 : 14 : btck_Context* btck_context_create(const btck_ContextOptions* options)
853 : : {
854 : 14 : bool sane{true};
855 : 14 : const ContextOptions* opts = options ? &btck_ContextOptions::get(options) : nullptr;
856 : 14 : auto context{std::make_shared<const Context>(opts, sane)};
857 [ - + ]: 14 : if (!sane) {
858 [ # # ]: 0 : LogError("Kernel context sanity check failed.");
859 : : return nullptr;
860 : : }
861 [ + - ]: 14 : return btck_Context::create(context);
862 : 14 : }
863 : :
864 : 5 : btck_Context* btck_context_copy(const btck_Context* context)
865 : : {
866 : 5 : return btck_Context::copy(context);
867 : : }
868 : :
869 : 1 : int btck_context_interrupt(btck_Context* context)
870 : : {
871 [ - + ]: 1 : return (*btck_Context::get(context)->m_interrupt)() ? 0 : -1;
872 : : }
873 : :
874 : 21 : void btck_context_destroy(btck_Context* context)
875 : : {
876 [ + + ]: 21 : delete context;
877 : 21 : }
878 : :
879 : 6 : const btck_BlockTreeEntry* btck_block_tree_entry_get_previous(const btck_BlockTreeEntry* entry)
880 : : {
881 [ + + ]: 6 : if (!btck_BlockTreeEntry::get(entry).pprev) {
882 : 2 : LogInfo("Genesis block has no previous.");
883 : 2 : return nullptr;
884 : : }
885 : :
886 : : return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);
887 : : }
888 : :
889 : 206 : btck_BlockValidationState* btck_block_validation_state_create()
890 : : {
891 : 206 : return btck_BlockValidationState::create();
892 : : }
893 : :
894 : 0 : btck_BlockValidationState* btck_block_validation_state_copy(const btck_BlockValidationState* state)
895 : : {
896 : 0 : return btck_BlockValidationState::copy(state);
897 : : }
898 : :
899 : 206 : void btck_block_validation_state_destroy(btck_BlockValidationState* state)
900 : : {
901 [ + - ]: 206 : delete state;
902 : 206 : }
903 : :
904 : 209 : btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
905 : : {
906 : 209 : auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
907 [ + + ]: 209 : if (block_validation_state.IsValid()) return btck_ValidationMode_VALID;
908 [ + - ]: 1 : if (block_validation_state.IsInvalid()) return btck_ValidationMode_INVALID;
909 : : return btck_ValidationMode_INTERNAL_ERROR;
910 : : }
911 : :
912 : 207 : btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState* block_validation_state_)
913 : : {
914 : 207 : auto& block_validation_state = btck_BlockValidationState::get(block_validation_state_);
915 [ - - + - : 207 : switch (block_validation_state.GetResult()) {
- - - - -
+ ]
916 : : case BlockValidationResult::BLOCK_RESULT_UNSET:
917 : : return btck_BlockValidationResult_UNSET;
918 : 0 : case BlockValidationResult::BLOCK_CONSENSUS:
919 : 0 : return btck_BlockValidationResult_CONSENSUS;
920 : 0 : case BlockValidationResult::BLOCK_CACHED_INVALID:
921 : 0 : return btck_BlockValidationResult_CACHED_INVALID;
922 : 1 : case BlockValidationResult::BLOCK_INVALID_HEADER:
923 : 1 : return btck_BlockValidationResult_INVALID_HEADER;
924 : 0 : case BlockValidationResult::BLOCK_MUTATED:
925 : 0 : return btck_BlockValidationResult_MUTATED;
926 : 0 : case BlockValidationResult::BLOCK_MISSING_PREV:
927 : 0 : return btck_BlockValidationResult_MISSING_PREV;
928 : 0 : case BlockValidationResult::BLOCK_INVALID_PREV:
929 : 0 : return btck_BlockValidationResult_INVALID_PREV;
930 : 0 : case BlockValidationResult::BLOCK_TIME_FUTURE:
931 : 0 : return btck_BlockValidationResult_TIME_FUTURE;
932 : 0 : case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
933 : 0 : return btck_BlockValidationResult_HEADER_LOW_WORK;
934 : : } // no default case, so the compiler can warn about missing cases
935 : 0 : assert(false);
936 : : }
937 : :
938 : 15 : btck_ChainstateManagerOptions* btck_chainstate_manager_options_create(const btck_Context* context, const char* data_dir, size_t data_dir_len, const char* blocks_dir, size_t blocks_dir_len)
939 : : {
940 [ + + + + ]: 15 : if (data_dir == nullptr || data_dir_len == 0 || blocks_dir == nullptr || blocks_dir_len == 0) {
941 : 4 : LogError("Failed to create chainstate manager options: dir must be non-null and non-empty");
942 : 4 : return nullptr;
943 : : }
944 : 11 : try {
945 [ + - + - : 22 : fs::path abs_data_dir{fs::absolute(fs::PathFromString({data_dir, data_dir_len}))};
+ - ]
946 [ + - ]: 11 : fs::create_directories(abs_data_dir);
947 [ + - + - : 22 : fs::path abs_blocks_dir{fs::absolute(fs::PathFromString({blocks_dir, blocks_dir_len}))};
+ - ]
948 [ + - ]: 11 : fs::create_directories(abs_blocks_dir);
949 [ + - ]: 11 : return btck_ChainstateManagerOptions::create(btck_Context::get(context), abs_data_dir, abs_blocks_dir);
950 [ - - ]: 22 : } catch (const std::exception& e) {
951 [ - - ]: 0 : LogError("Failed to create chainstate manager options: %s", e.what());
952 : 0 : return nullptr;
953 : 0 : }
954 : : }
955 : :
956 : 1 : void btck_chainstate_manager_options_set_worker_threads_num(btck_ChainstateManagerOptions* opts, int worker_threads)
957 : : {
958 : 1 : LOCK(btck_ChainstateManagerOptions::get(opts).m_mutex);
959 [ + - ]: 1 : btck_ChainstateManagerOptions::get(opts).m_chainman_options.worker_threads_num = worker_threads;
960 : 1 : }
961 : :
962 : 11 : void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* options)
963 : : {
964 [ + - ]: 11 : delete options;
965 : 11 : }
966 : :
967 : 6 : int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions* chainman_opts, int wipe_block_tree_db, int wipe_chainstate_db)
968 : : {
969 [ + + ]: 6 : if (wipe_block_tree_db == 1 && wipe_chainstate_db != 1) {
970 : 1 : LogError("Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
971 : 1 : return -1;
972 : : }
973 : 5 : auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
974 : 5 : LOCK(opts.m_mutex);
975 : 5 : opts.m_blockman_options.block_tree_db_params.wipe_data = wipe_block_tree_db == 1;
976 : 5 : opts.m_chainstate_load_options.wipe_chainstate_db = wipe_chainstate_db == 1;
977 [ + - ]: 5 : return 0;
978 : 5 : }
979 : :
980 : 2 : void btck_chainstate_manager_options_update_block_tree_db_in_memory(
981 : : btck_ChainstateManagerOptions* chainman_opts,
982 : : int block_tree_db_in_memory)
983 : : {
984 : 2 : auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
985 : 2 : LOCK(opts.m_mutex);
986 [ + - ]: 2 : opts.m_blockman_options.block_tree_db_params.memory_only = block_tree_db_in_memory == 1;
987 : 2 : }
988 : :
989 : 2 : void btck_chainstate_manager_options_update_chainstate_db_in_memory(
990 : : btck_ChainstateManagerOptions* chainman_opts,
991 : : int chainstate_db_in_memory)
992 : : {
993 : 2 : auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
994 : 2 : LOCK(opts.m_mutex);
995 [ + - ]: 2 : opts.m_chainstate_load_options.coins_db_in_memory = chainstate_db_in_memory == 1;
996 : 2 : }
997 : :
998 : 11 : btck_ChainstateManager* btck_chainstate_manager_create(
999 : : const btck_ChainstateManagerOptions* chainman_opts)
1000 : : {
1001 : 11 : auto& opts{btck_ChainstateManagerOptions::get(chainman_opts)};
1002 : 11 : std::unique_ptr<ChainstateManager> chainman;
1003 : 11 : try {
1004 [ + - ]: 11 : LOCK(opts.m_mutex);
1005 [ + - + - ]: 22 : chainman = std::make_unique<ChainstateManager>(*opts.m_context->m_interrupt, opts.m_chainman_options, opts.m_blockman_options);
1006 [ - - ]: 0 : } catch (const std::exception& e) {
1007 [ - - ]: 0 : LogError("Failed to create chainstate manager: %s", e.what());
1008 : 0 : return nullptr;
1009 : 0 : }
1010 : :
1011 : 11 : try {
1012 [ + - + - ]: 33 : const auto chainstate_load_opts{WITH_LOCK(opts.m_mutex, return opts.m_chainstate_load_options)};
1013 : :
1014 [ + - ]: 11 : kernel::CacheSizes cache_sizes{DEFAULT_KERNEL_CACHE};
1015 [ + - - + ]: 11 : auto [status, chainstate_err]{node::LoadChainstate(*chainman, cache_sizes, chainstate_load_opts)};
1016 [ - + ]: 11 : if (status != node::ChainstateLoadStatus::SUCCESS) {
1017 [ # # ]: 0 : LogError("Failed to load chain state from your data directory: %s", chainstate_err.original);
1018 : : return nullptr;
1019 : : }
1020 [ + - ]: 11 : std::tie(status, chainstate_err) = node::VerifyLoadedChainstate(*chainman, chainstate_load_opts);
1021 [ - + ]: 11 : if (status != node::ChainstateLoadStatus::SUCCESS) {
1022 [ # # ]: 0 : LogError("Failed to verify loaded chain state from your datadir: %s", chainstate_err.original);
1023 : : return nullptr;
1024 : : }
1025 [ + - - + ]: 11 : if (auto result = chainman->ActivateBestChains(); !result) {
1026 [ # # # # ]: 0 : LogError("%s", util::ErrorString(result).original);
1027 : 0 : return nullptr;
1028 : 11 : }
1029 [ - - ]: 11 : } catch (const std::exception& e) {
1030 [ - - ]: 0 : LogError("Failed to load chainstate: %s", e.what());
1031 : 0 : return nullptr;
1032 : 0 : }
1033 : :
1034 [ + - ]: 11 : return btck_ChainstateManager::create(std::move(chainman), opts.m_context);
1035 : 11 : }
1036 : :
1037 : 207 : const btck_BlockTreeEntry* btck_chainstate_manager_get_block_tree_entry_by_hash(const btck_ChainstateManager* chainman, const btck_BlockHash* block_hash)
1038 : : {
1039 [ + - + - ]: 621 : auto block_index = WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(),
1040 : : return btck_ChainstateManager::get(chainman).m_chainman->m_blockman.LookupBlockIndex(btck_BlockHash::get(block_hash)));
1041 [ - + ]: 207 : if (!block_index) {
1042 [ # # ]: 0 : LogDebug(BCLog::KERNEL, "A block with the given hash is not indexed.");
1043 : 0 : return nullptr;
1044 : : }
1045 : : return btck_BlockTreeEntry::ref(block_index);
1046 : : }
1047 : :
1048 : 206 : const btck_BlockTreeEntry* btck_chainstate_manager_get_best_entry(const btck_ChainstateManager* chainstate_manager)
1049 : : {
1050 : 206 : auto& chainman = *btck_ChainstateManager::get(chainstate_manager).m_chainman;
1051 [ + - ]: 412 : return btck_BlockTreeEntry::ref(WITH_LOCK(chainman.GetMutex(), return chainman.m_best_header));
1052 : : }
1053 : :
1054 : 11 : void btck_chainstate_manager_destroy(btck_ChainstateManager* chainman)
1055 : : {
1056 : 11 : {
1057 : 11 : LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex());
1058 [ + + ]: 22 : for (const auto& chainstate : btck_ChainstateManager::get(chainman).m_chainman->m_chainstates) {
1059 [ + - ]: 22 : if (chainstate->CanFlushToDisk()) {
1060 [ + - ]: 11 : chainstate->ForceFlushStateToDisk();
1061 : 11 : chainstate->ResetCoinsViews();
1062 : : }
1063 : : }
1064 : 11 : }
1065 : :
1066 [ + - ]: 11 : delete chainman;
1067 : 11 : }
1068 : :
1069 : 2 : int btck_chainstate_manager_import_blocks(btck_ChainstateManager* chainman, const char** block_file_paths_data, size_t* block_file_paths_lens, size_t block_file_paths_data_len)
1070 : : {
1071 : 2 : try {
1072 : 2 : std::vector<fs::path> import_files;
1073 [ + - ]: 2 : import_files.reserve(block_file_paths_data_len);
1074 [ + + ]: 3 : for (uint32_t i = 0; i < block_file_paths_data_len; i++) {
1075 [ + - ]: 1 : if (block_file_paths_data[i] != nullptr) {
1076 [ + - + - ]: 2 : import_files.emplace_back(std::string{block_file_paths_data[i], block_file_paths_lens[i]}.c_str());
1077 : : }
1078 : : }
1079 [ - + + - ]: 2 : node::ImportBlocks(*btck_ChainstateManager::get(chainman).m_chainman, import_files);
1080 [ - - ]: 0 : } catch (const std::exception& e) {
1081 [ - - ]: 0 : LogError("Failed to import blocks: %s", e.what());
1082 : 0 : return -1;
1083 : 0 : }
1084 : 2 : return 0;
1085 : : }
1086 : :
1087 : 629 : btck_Block* btck_block_create(const void* raw_block, size_t raw_block_length)
1088 : : {
1089 [ + - ]: 629 : if (raw_block == nullptr && raw_block_length != 0) {
1090 : : return nullptr;
1091 : : }
1092 : 629 : auto block{std::make_shared<CBlock>()};
1093 : :
1094 [ + - ]: 629 : DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_block), raw_block_length}};
1095 : :
1096 : 629 : try {
1097 [ + + ]: 629 : stream >> TX_WITH_WITNESS(*block);
1098 : 2 : } catch (...) {
1099 [ + - + - : 2 : LogDebug(BCLog::KERNEL, "Block decode failed.");
+ - ]
1100 : 2 : return nullptr;
1101 [ + - ]: 2 : }
1102 : :
1103 [ + - ]: 627 : return btck_Block::create(block);
1104 [ + - ]: 1258 : }
1105 : :
1106 : 5 : btck_Block* btck_block_copy(const btck_Block* block)
1107 : : {
1108 : 5 : return btck_Block::copy(block);
1109 : : }
1110 : :
1111 : 2802 : size_t btck_block_count_transactions(const btck_Block* block)
1112 : : {
1113 [ - + ]: 2802 : return btck_Block::get(block)->vtx.size();
1114 : : }
1115 : :
1116 : 2928 : const btck_Transaction* btck_block_get_transaction_at(const btck_Block* block, size_t index)
1117 : : {
1118 [ - + - + ]: 2928 : assert(index < btck_Block::get(block)->vtx.size());
1119 : 2928 : return btck_Transaction::ref(&btck_Block::get(block)->vtx[index]);
1120 : : }
1121 : :
1122 : 208 : btck_BlockHeader* btck_block_get_header(const btck_Block* block)
1123 : : {
1124 : 208 : const auto& block_ptr = btck_Block::get(block);
1125 : 208 : return btck_BlockHeader::create(static_cast<const CBlockHeader&>(*block_ptr));
1126 : : }
1127 : :
1128 : 20 : int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* user_data)
1129 : : {
1130 : 20 : try {
1131 : 20 : WriterStream ws{writer, user_data};
1132 [ + - ]: 40 : ws << TX_WITH_WITNESS(*btck_Block::get(block));
1133 : : return 0;
1134 : 0 : } catch (...) {
1135 : 0 : return -1;
1136 : 0 : }
1137 : : }
1138 : :
1139 : 1 : btck_BlockHash* btck_block_get_hash(const btck_Block* block)
1140 : : {
1141 : 1 : return btck_BlockHash::create(btck_Block::get(block)->GetHash());
1142 : : }
1143 : :
1144 : 3431 : void btck_block_destroy(btck_Block* block)
1145 : : {
1146 [ + + ]: 3431 : delete block;
1147 : 3431 : }
1148 : :
1149 : 2789 : btck_Block* btck_block_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
1150 : : {
1151 : 2789 : auto block{std::make_shared<CBlock>()};
1152 [ + - + + ]: 2789 : if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlock(*block, btck_BlockTreeEntry::get(entry))) {
1153 [ + - ]: 1 : LogError("Failed to read block.");
1154 : : return nullptr;
1155 : : }
1156 [ + - ]: 2788 : return btck_Block::create(block);
1157 : 2789 : }
1158 : :
1159 : 206 : btck_BlockHeader* btck_block_tree_entry_get_block_header(const btck_BlockTreeEntry* entry)
1160 : : {
1161 : 206 : return btck_BlockHeader::create(btck_BlockTreeEntry::get(entry).GetBlockHeader());
1162 : : }
1163 : :
1164 : 211 : int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry* entry)
1165 : : {
1166 : 211 : return btck_BlockTreeEntry::get(entry).nHeight;
1167 : : }
1168 : :
1169 : 207 : const btck_BlockHash* btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry* entry)
1170 : : {
1171 : 207 : return btck_BlockHash::ref(btck_BlockTreeEntry::get(entry).phashBlock);
1172 : : }
1173 : :
1174 : 7 : int btck_block_tree_entry_equals(const btck_BlockTreeEntry* entry1, const btck_BlockTreeEntry* entry2)
1175 : : {
1176 : 7 : return &btck_BlockTreeEntry::get(entry1) == &btck_BlockTreeEntry::get(entry2);
1177 : : }
1178 : :
1179 : 2 : btck_BlockHash* btck_block_hash_create(const unsigned char block_hash[32])
1180 : : {
1181 : 2 : return btck_BlockHash::create(std::span<const unsigned char>{block_hash, 32});
1182 : : }
1183 : :
1184 : 212 : btck_BlockHash* btck_block_hash_copy(const btck_BlockHash* block_hash)
1185 : : {
1186 : 212 : return btck_BlockHash::copy(block_hash);
1187 : : }
1188 : :
1189 : 6 : void btck_block_hash_to_bytes(const btck_BlockHash* block_hash, unsigned char output[32])
1190 : : {
1191 : 6 : std::memcpy(output, btck_BlockHash::get(block_hash).begin(), 32);
1192 : 6 : }
1193 : :
1194 : 208 : int btck_block_hash_equals(const btck_BlockHash* hash1, const btck_BlockHash* hash2)
1195 : : {
1196 : 208 : return btck_BlockHash::get(hash1) == btck_BlockHash::get(hash2);
1197 : : }
1198 : :
1199 : 632 : void btck_block_hash_destroy(btck_BlockHash* hash)
1200 : : {
1201 [ + + ]: 632 : delete hash;
1202 : 632 : }
1203 : :
1204 : 5 : btck_BlockSpentOutputs* btck_block_spent_outputs_read(const btck_ChainstateManager* chainman, const btck_BlockTreeEntry* entry)
1205 : : {
1206 : 5 : auto block_undo{std::make_shared<CBlockUndo>()};
1207 [ + + ]: 5 : if (btck_BlockTreeEntry::get(entry).nHeight < 1) {
1208 [ + - + - : 1 : LogDebug(BCLog::KERNEL, "The genesis block does not have any spent outputs.");
+ - ]
1209 [ + - ]: 1 : return btck_BlockSpentOutputs::create(block_undo);
1210 : : }
1211 [ + - + + ]: 4 : if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlockUndo(*block_undo, btck_BlockTreeEntry::get(entry))) {
1212 [ + - ]: 1 : LogError("Failed to read block spent outputs data.");
1213 : : return nullptr;
1214 : : }
1215 [ + - ]: 3 : return btck_BlockSpentOutputs::create(block_undo);
1216 : 5 : }
1217 : :
1218 : 5 : btck_BlockSpentOutputs* btck_block_spent_outputs_copy(const btck_BlockSpentOutputs* block_spent_outputs)
1219 : : {
1220 : 5 : return btck_BlockSpentOutputs::copy(block_spent_outputs);
1221 : : }
1222 : :
1223 : 28 : size_t btck_block_spent_outputs_count(const btck_BlockSpentOutputs* block_spent_outputs)
1224 : : {
1225 [ - + ]: 28 : return btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size();
1226 : : }
1227 : :
1228 : 20 : const btck_TransactionSpentOutputs* btck_block_spent_outputs_get_transaction_spent_outputs_at(const btck_BlockSpentOutputs* block_spent_outputs, size_t transaction_index)
1229 : : {
1230 [ - + - + ]: 20 : assert(transaction_index < btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.size());
1231 : 20 : const auto* tx_undo{&btck_BlockSpentOutputs::get(block_spent_outputs)->vtxundo.at(transaction_index)};
1232 : 20 : return btck_TransactionSpentOutputs::ref(tx_undo);
1233 : : }
1234 : :
1235 : 11 : void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs* block_spent_outputs)
1236 : : {
1237 [ + + ]: 11 : delete block_spent_outputs;
1238 : 11 : }
1239 : :
1240 : 7 : btck_TransactionSpentOutputs* btck_transaction_spent_outputs_copy(const btck_TransactionSpentOutputs* transaction_spent_outputs)
1241 : : {
1242 : 7 : return btck_TransactionSpentOutputs::copy(transaction_spent_outputs);
1243 : : }
1244 : :
1245 : 24 : size_t btck_transaction_spent_outputs_count(const btck_TransactionSpentOutputs* transaction_spent_outputs)
1246 : : {
1247 [ - + ]: 24 : return btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size();
1248 : : }
1249 : :
1250 : 9 : void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs* transaction_spent_outputs)
1251 : : {
1252 [ + + ]: 9 : delete transaction_spent_outputs;
1253 : 9 : }
1254 : :
1255 : 18 : const btck_Coin* btck_transaction_spent_outputs_get_coin_at(const btck_TransactionSpentOutputs* transaction_spent_outputs, size_t coin_index)
1256 : : {
1257 [ - + - + ]: 18 : assert(coin_index < btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.size());
1258 : 18 : const Coin* coin{&btck_TransactionSpentOutputs::get(transaction_spent_outputs).vprevout.at(coin_index)};
1259 : 18 : return btck_Coin::ref(coin);
1260 : : }
1261 : :
1262 : 7 : btck_Coin* btck_coin_copy(const btck_Coin* coin)
1263 : : {
1264 : 7 : return btck_Coin::copy(coin);
1265 : : }
1266 : :
1267 : 1 : uint32_t btck_coin_confirmation_height(const btck_Coin* coin)
1268 : : {
1269 : 1 : return btck_Coin::get(coin).nHeight;
1270 : : }
1271 : :
1272 : 1 : int btck_coin_is_coinbase(const btck_Coin* coin)
1273 : : {
1274 [ + - ]: 1 : return btck_Coin::get(coin).IsCoinBase() ? 1 : 0;
1275 : : }
1276 : :
1277 : 3 : const btck_TransactionOutput* btck_coin_get_output(const btck_Coin* coin)
1278 : : {
1279 : 3 : return btck_TransactionOutput::ref(&btck_Coin::get(coin).out);
1280 : : }
1281 : :
1282 : 9 : void btck_coin_destroy(btck_Coin* coin)
1283 : : {
1284 [ + + ]: 9 : delete coin;
1285 : 9 : }
1286 : :
1287 : 418 : int btck_chainstate_manager_process_block(
1288 : : btck_ChainstateManager* chainman,
1289 : : const btck_Block* block,
1290 : : int* _new_block)
1291 : : {
1292 : 418 : bool new_block;
1293 : 418 : auto result = btck_ChainstateManager::get(chainman).m_chainman->ProcessNewBlock(btck_Block::get(block), /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
1294 [ + - ]: 418 : if (_new_block) {
1295 [ + + ]: 420 : *_new_block = new_block ? 1 : 0;
1296 : : }
1297 [ + + ]: 418 : return result ? 0 : -1;
1298 : : }
1299 : :
1300 : 206 : int btck_chainstate_manager_process_block_header(
1301 : : btck_ChainstateManager* chainstate_manager,
1302 : : const btck_BlockHeader* header,
1303 : : btck_BlockValidationState* state)
1304 : : {
1305 : 206 : try {
1306 : 206 : auto& chainman = btck_ChainstateManager::get(chainstate_manager).m_chainman;
1307 [ + - ]: 206 : auto result = chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1}, /*min_pow_checked=*/true, btck_BlockValidationState::get(state), /*ppindex=*/nullptr);
1308 : :
1309 [ - + ]: 206 : return result ? 0 : -1;
1310 [ - - ]: 0 : } catch (const std::exception& e) {
1311 [ - - ]: 0 : LogError("Failed to process block header: %s", e.what());
1312 : 0 : return -1;
1313 : 0 : }
1314 : : }
1315 : :
1316 : 236 : const btck_Chain* btck_chainstate_manager_get_active_chain(const btck_ChainstateManager* chainman)
1317 : : {
1318 [ + - + - ]: 708 : return btck_Chain::ref(&WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(), return btck_ChainstateManager::get(chainman).m_chainman->ActiveChain()));
1319 : : }
1320 : :
1321 : 260 : int btck_chain_get_height(const btck_Chain* chain)
1322 : : {
1323 : 260 : LOCK(::cs_main);
1324 [ - + + - ]: 260 : return btck_Chain::get(chain).Height();
1325 : 260 : }
1326 : :
1327 : 3627 : const btck_BlockTreeEntry* btck_chain_get_by_height(const btck_Chain* chain, int height)
1328 : : {
1329 : 3627 : LOCK(::cs_main);
1330 [ + - + - ]: 7254 : return btck_BlockTreeEntry::ref(btck_Chain::get(chain)[height]);
1331 : 3627 : }
1332 : :
1333 : 207 : int btck_chain_contains(const btck_Chain* chain, const btck_BlockTreeEntry* entry)
1334 : : {
1335 : 207 : LOCK(::cs_main);
1336 [ + + ]: 207 : return btck_Chain::get(chain).Contains(&btck_BlockTreeEntry::get(entry)) ? 1 : 0;
1337 : 207 : }
1338 : :
1339 : 5 : btck_BlockHeader* btck_block_header_create(const void* raw_block_header, size_t raw_block_header_len)
1340 : : {
1341 [ + - ]: 5 : if (raw_block_header == nullptr && raw_block_header_len != 0) {
1342 : : return nullptr;
1343 : : }
1344 : 5 : auto header{std::make_unique<CBlockHeader>()};
1345 [ + - ]: 5 : DataStream stream{std::span{reinterpret_cast<const std::byte*>(raw_block_header), raw_block_header_len}};
1346 : :
1347 : 5 : try {
1348 [ + + ]: 5 : stream >> *header;
1349 : 2 : } catch (...) {
1350 [ + - ]: 2 : LogError("Block header decode failed.");
1351 : 2 : return nullptr;
1352 [ + - ]: 2 : }
1353 : :
1354 : 3 : return btck_BlockHeader::ref(header.release());
1355 : 5 : }
1356 : :
1357 : 5 : btck_BlockHeader* btck_block_header_copy(const btck_BlockHeader* header)
1358 : : {
1359 : 5 : return btck_BlockHeader::copy(header);
1360 : : }
1361 : :
1362 : 415 : btck_BlockHash* btck_block_header_get_hash(const btck_BlockHeader* header)
1363 : : {
1364 : 415 : return btck_BlockHash::create(btck_BlockHeader::get(header).GetHash());
1365 : : }
1366 : :
1367 : 1 : const btck_BlockHash* btck_block_header_get_prev_hash(const btck_BlockHeader* header)
1368 : : {
1369 : 1 : return btck_BlockHash::ref(&btck_BlockHeader::get(header).hashPrevBlock);
1370 : : }
1371 : :
1372 : 3 : uint32_t btck_block_header_get_timestamp(const btck_BlockHeader* header)
1373 : : {
1374 : 3 : return btck_BlockHeader::get(header).nTime;
1375 : : }
1376 : :
1377 : 3 : uint32_t btck_block_header_get_bits(const btck_BlockHeader* header)
1378 : : {
1379 : 3 : return btck_BlockHeader::get(header).nBits;
1380 : : }
1381 : :
1382 : 3 : int32_t btck_block_header_get_version(const btck_BlockHeader* header)
1383 : : {
1384 : 3 : return btck_BlockHeader::get(header).nVersion;
1385 : : }
1386 : :
1387 : 3 : uint32_t btck_block_header_get_nonce(const btck_BlockHeader* header)
1388 : : {
1389 : 3 : return btck_BlockHeader::get(header).nNonce;
1390 : : }
1391 : :
1392 : 424 : void btck_block_header_destroy(btck_BlockHeader* header)
1393 : : {
1394 [ + + ]: 424 : delete header;
1395 : 424 : }
|
