5#define BITCOINKERNEL_BUILD
93 : m_writer{
writer}, m_user_data{user_data} {}
98 void write(std::span<const std::byte>
src)
100 if (m_writer(
src.data(),
src.size(), m_user_data) != 0) {
101 throw std::runtime_error(
"Failed to write serialization data");
105 template <
typename T>
113template <
typename C,
typename CPP>
122 return reinterpret_cast<const C*
>(
cpp_type);
125 template <
typename... Args>
126 static C* create(Args&&...
args)
128 auto cpp_obj{std::make_unique<CPP>(std::forward<Args>(
args)...)};
132 static C* copy(
const C* ptr)
134 auto cpp_obj{std::make_unique<CPP>(get(ptr))};
138 static const CPP& get(
const C* ptr)
140 return *
reinterpret_cast<const CPP*
>(ptr);
143 static CPP& get(
C* ptr)
145 return *
reinterpret_cast<CPP*
>(ptr);
148 static void operator delete(
void* ptr)
150 delete reinterpret_cast<CPP*
>(ptr);
158struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};
234 return {.
data = str.data(), .len = str.size()};
255#ifdef DEBUG_LOCKCONTENTION
256 case BCLog::LogFlags::LOCK: {
302 ~KernelNotifications()
363 btck_Block::copy(btck_Block::ref(&block)),
364 btck_BlockValidationState::ref(&
stateIn));
372 btck_Block::copy(btck_Block::ref(&block)),
373 btck_BlockTreeEntry::ref(pindex));
381 btck_Block::copy(btck_Block::ref(&block)),
382 btck_BlockTreeEntry::ref(pindex));
390 btck_Block::copy(btck_Block::ref(&block)),
391 btck_BlockTreeEntry::ref(pindex));
396struct ContextOptions {
397 mutable Mutex m_mutex;
398 std::unique_ptr<const CChainParams> m_chainparams
GUARDED_BY(m_mutex);
400 std::shared_ptr<KernelValidationInterface> m_validation_interface
GUARDED_BY(m_mutex);
406 std::unique_ptr<kernel::Context>
m_context;
410 std::unique_ptr<util::SignalInterrupt> m_interrupt;
412 std::unique_ptr<ValidationSignals>
m_signals;
414 std::unique_ptr<const CChainParams> m_chainparams;
416 std::shared_ptr<KernelValidationInterface> m_validation_interface;
418 Context(
const ContextOptions* options,
bool&
sane)
423 LOCK(options->m_mutex);
424 if (options->m_chainparams) {
425 m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
427 if (options->m_notifications) {
430 if (options->m_validation_interface) {
431 m_signals = std::make_unique<ValidationSignals>(std::make_unique<ImmediateTaskRunner>());
432 m_validation_interface = options->m_validation_interface;
437 if (!m_chainparams) {
440 if (!m_notifications) {
442 nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr});
459struct ChainstateManagerOptions {
460 mutable Mutex m_mutex;
463 std::shared_ptr<const Context>
m_context;
467 ChainstateManagerOptions(
const std::shared_ptr<const Context>&
context,
const fs::path&
data_dir,
const fs::path& blocks_dir)
469 .chainparams = *
context->m_chainparams,
474 .chainparams = *
context->m_chainparams,
475 .blocks_dir = blocks_dir,
478 .path =
data_dir /
"blocks" /
"index",
487 std::unique_ptr<ChainstateManager> m_chainman;
488 std::shared_ptr<const Context>
m_context;
490 ChainMan(std::unique_ptr<ChainstateManager> chainman, std::shared_ptr<const Context>
context)
494struct UserDataDeleter {
496 void operator()(
void* user_data)
const
498 if (destroy) destroy(user_data);
502using UserData = std::unique_ptr<void, UserDataDeleter>;
513 void operator()(
const btck_LogEntry* entry)
const { fn(user_data.get(), entry); }
518 std::list<Callback> m_callbacks
GUARDED_BY(m_mutex);
520 std::atomic<size_t> m_callback_count{0};
533 KernelLogger* m_logger;
534 std::list<Callback>::iterator m_it;
538 : m_logger{&
logger}, m_it{it} {}
539 CallbackHandle(CallbackHandle&& other) noexcept
540 : m_logger{std::exchange(other.m_logger,
nullptr)}, m_it{other.m_it} {}
541 CallbackHandle& operator=(CallbackHandle&&) =
delete;
544 if (m_logger) m_logger->UnregisterCallback(m_it);
553 m_min_level.store(
to_util(level), std::memory_order_relaxed);
559 return level >= m_min_level.load(std::memory_order_relaxed) &&
560 m_callback_count.load(std::memory_order_relaxed) > 0;
577 Callback
cb{fn, std::move(user_data)};
579 m_callbacks.push_back(std::move(
cb));
580 m_callback_count.fetch_add(1, std::memory_order_relaxed);
581 return {*
this, std::prev(m_callbacks.end())};
584void KernelLogger::UnregisterCallback(std::list<Callback>::iterator it)
587 std::list<Callback>
dying;
591 m_callback_count.fetch_sub(1, std::memory_order_relaxed);
598 for (
const auto& callback : m_callbacks) {
600 callback(btck_LogEntry::ref(&entry));
615struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};
646 return btck_Transaction::get(
transaction)->vout.size();
658 return btck_Transaction::get(
transaction)->vin.size();
669 return btck_Transaction::get(
transaction)->version;
674 return btck_Transaction::get(
transaction)->nLockTime;
679 return btck_Txid::ref(&btck_Transaction::get(
transaction)->GetHash());
684 return btck_Transaction::get(
transaction)->HasWitness() ? 1 : 0;
689 return btck_Wtxid::ref(&btck_Transaction::get(
transaction)->GetWitnessHash());
700 WriterStream ws{
writer, user_data};
717 return btck_ScriptPubkey::create(
data.begin(),
data.end());
722 const auto& script_pubkey{btck_ScriptPubkey::get(
script_pubkey_)};
723 return writer(script_pubkey.data(), script_pubkey.size(), user_data);
728 return btck_ScriptPubkey::copy(script_pubkey);
733 delete script_pubkey;
738 return btck_TransactionOutput::create(amount, btck_ScriptPubkey::get(script_pubkey));
743 return btck_TransactionOutput::copy(output);
748 return btck_ScriptPubkey::ref(&btck_TransactionOutput::get(output).scriptPubKey);
753 return btck_TransactionOutput::get(output).nValue;
767 auto txdata{btck_PrecomputedTransactionData::create()};
776 btck_PrecomputedTransactionData::get(txdata).Init(tx, std::move(
spent_outputs));
778 btck_PrecomputedTransactionData::get(txdata).Init(tx, {});
826 btck_ScriptPubkey::get(script_pubkey),
831 return result ? 1 : 0;
836 return btck_TransactionInput::copy(input);
841 return btck_TransactionOutPoint::ref(&btck_TransactionInput::get(input).prevout);
846 return btck_TransactionInput::get(input).nSequence;
851 return btck_WitnessStack::ref(&btck_TransactionInput::get(input).scriptWitness);
856 const auto&
script_sig{btck_TransactionInput::get(input).scriptSig};
872 const auto& stack{btck_WitnessStack::get(
witness_stack).stack};
873 assert(index < stack.size());
874 return writer(stack[index].
data(), stack[index].size(), user_data);
889 return btck_TransactionOutPoint::copy(
out_point);
894 return btck_TransactionOutPoint::get(
out_point).n;
899 return btck_Txid::ref(&btck_TransactionOutPoint::get(
out_point).hash);
909 return btck_Txid::copy(txid);
914 std::memcpy(output, btck_Txid::get(txid).begin(), 32);
919 return btck_Txid::get(
txid1) == btck_Txid::get(
txid2);
929 return btck_Wtxid::copy(
wtxid);
934 std::memcpy(output, btck_Wtxid::get(
wtxid).begin(), 32);
939 return btck_Wtxid::get(
wtxid1) == btck_Wtxid::get(
wtxid2);
952 static KernelLogger*
logger{
new KernelLogger};
992 return btck_LoggingConnection::create(std::move(
handle));
1000 if (!connection)
return;
1013 return to_btck(btck_LogEntry::get(entry).thread_name);
1023 return btck_LogEntry::get(entry).mocktime.count();
1028 return to_btck(btck_LogEntry::get(entry).source_loc.file_name());
1033 return to_btck(btck_LogEntry::get(entry).source_loc.function_name_short());
1038 return btck_LogEntry::get(entry).source_loc.line();
1043 return to_btck(btck_LogEntry::get(entry).level);
1090 return btck_ConsensusParams::ref(&btck_ChainParameters::get(
chain_parameters).GetConsensus());
1100 return btck_ContextOptions::create();
1106 LOCK(btck_ContextOptions::get(options).m_mutex);
1107 btck_ContextOptions::get(options).m_chainparams = std::make_unique<const CChainParams>(btck_ChainParameters::get(
chain_parameters));
1113 LOCK(btck_ContextOptions::get(options).m_mutex);
1114 btck_ContextOptions::get(options).m_notifications = std::make_shared<KernelNotifications>(notifications);
1119 LOCK(btck_ContextOptions::get(options).m_mutex);
1120 btck_ContextOptions::get(options).m_validation_interface = std::make_shared<KernelValidationInterface>(
vi_cbs);
1131 const ContextOptions* opts = options ? &btck_ContextOptions::get(options) :
nullptr;
1132 auto context{std::make_shared<const Context>(opts,
sane)};
1134 LogError(
"Kernel context sanity check failed.");
1137 return btck_Context::create(
context);
1142 return btck_Context::copy(
context);
1147 return (*btck_Context::get(
context)->m_interrupt)() ? 0 : -1;
1157 if (!btck_BlockTreeEntry::get(entry).pprev) {
1158 LogInfo(
"Genesis block has no previous.");
1162 return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);
1169 return btck_BlockTreeEntry::ref(
ancestor);
1174 return btck_BlockValidationState::create();
1179 return btck_BlockValidationState::copy(state);
1226 LogError(
"Failed to create chainstate manager options: dir must be non-null and non-empty");
1235 }
catch (
const std::exception&
e) {
1236 LogError(
"Failed to create chainstate manager options: %s",
e.what());
1243 LOCK(btck_ChainstateManagerOptions::get(opts).m_mutex);
1244 btck_ChainstateManagerOptions::get(opts).m_chainman_options.worker_threads_num =
worker_threads;
1250 LogError(
"Failed to set database cache: size is outside the supported range.");
1254 auto& opts{btck_ChainstateManagerOptions::get(
chainman_opts)};
1269 LogError(
"Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
1272 auto& opts{btck_ChainstateManagerOptions::get(
chainman_opts)};
1275 opts.m_chainstate_load_options.wipe_chainstate_db = wipe_chainstate_db == 1;
1281 int block_tree_db_in_memory)
1283 auto& opts{btck_ChainstateManagerOptions::get(
chainman_opts)};
1285 opts.m_blockman_options.block_tree_db_params.memory_only = block_tree_db_in_memory == 1;
1292 auto& opts{btck_ChainstateManagerOptions::get(
chainman_opts)};
1300 auto& opts{btck_ChainstateManagerOptions::get(
chainman_opts)};
1301 std::unique_ptr<ChainstateManager> chainman;
1304 chainman = std::make_unique<ChainstateManager>(*opts.m_context->m_interrupt, opts.m_chainman_options, opts.m_blockman_options);
1305 }
catch (
const std::exception&
e) {
1306 LogError(
"Failed to create chainstate manager: %s",
e.what());
1324 if (
auto result = chainman->ActivateBestChains(); !result) {
1328 }
catch (
const std::exception&
e) {
1329 LogError(
"Failed to load chainstate: %s",
e.what());
1333 return btck_ChainstateManager::create(std::move(chainman), opts.m_context);
1339 return btck_ChainstateManager::get(chainman).m_chainman->m_blockman.LookupBlockIndex(btck_BlockHash::get(block_hash)));
1350 return btck_BlockTreeEntry::ref(
WITH_LOCK(chainman.GetMutex(),
return chainman.m_best_header));
1356 LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex());
1357 for (
const auto&
chainstate : btck_ChainstateManager::get(chainman).m_chainman->m_chainstates) {
1378 auto&
chainman_ref{*btck_ChainstateManager::get(chainman).m_chainman};
1381 }
catch (
const std::exception&
e) {
1382 LogError(
"Failed to import blocks: %s",
e.what());
1391 auto block{std::make_shared<CBlock>()};
1402 return btck_Block::create(block);
1407 return btck_Block::copy(block);
1420 return result ? 1 : 0;
1425 return btck_Block::get(block)->vtx.size();
1430 assert(index < btck_Block::get(block)->vtx.size());
1431 return btck_Transaction::ref(&btck_Block::get(block)->vtx[index]);
1436 const auto&
block_ptr = btck_Block::get(block);
1443 WriterStream ws{
writer, user_data};
1453 return btck_BlockHash::create(btck_Block::get(block)->GetHash());
1463 auto block{std::make_shared<CBlock>()};
1464 if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlock(*block, btck_BlockTreeEntry::get(entry))) {
1468 return btck_Block::create(block);
1473 return btck_BlockHeader::create(btck_BlockTreeEntry::get(entry).GetBlockHeader());
1478 return btck_BlockTreeEntry::get(entry).nHeight;
1483 return btck_BlockHash::ref(btck_BlockTreeEntry::get(entry).phashBlock);
1488 return &btck_BlockTreeEntry::get(
entry1) == &btck_BlockTreeEntry::get(
entry2);
1493 return btck_BlockHash::create(std::span<const unsigned char>{block_hash, 32});
1498 return btck_BlockHash::copy(block_hash);
1503 std::memcpy(output, btck_BlockHash::get(block_hash).begin(), 32);
1508 return btck_BlockHash::get(
hash1) == btck_BlockHash::get(
hash2);
1518 auto block_undo{std::make_shared<CBlockUndo>()};
1519 if (btck_BlockTreeEntry::get(entry).
nHeight < 1) {
1521 return btck_BlockSpentOutputs::create(
block_undo);
1523 if (!btck_ChainstateManager::get(chainman).m_chainman->m_blockman.ReadBlockUndo(*
block_undo, btck_BlockTreeEntry::get(entry))) {
1524 LogError(
"Failed to read block spent outputs data.");
1527 return btck_BlockSpentOutputs::create(
block_undo);
1544 return btck_TransactionSpentOutputs::ref(
tx_undo);
1571 return btck_Coin::ref(coin);
1576 return btck_Coin::copy(coin);
1581 return btck_Coin::get(coin).nHeight;
1586 return btck_Coin::get(coin).IsCoinBase() ? 1 : 0;
1591 return btck_TransactionOutput::ref(&btck_Coin::get(coin).out);
1605 auto result = btck_ChainstateManager::get(chainman).m_chainman->ProcessNewBlock(btck_Block::get(block),
true,
true, &
new_block);
1609 return result ? 0 : -1;
1619 auto state = btck_BlockValidationState::create();
1620 bool result{chainman->ProcessNewBlockHeaders({&btck_BlockHeader::get(header), 1},
true, btck_BlockValidationState::get(state))};
1621 assert(result == btck_BlockValidationState::get(state).IsValid());
1623 }
catch (
const std::exception&
e) {
1624 LogError(
"Failed to process block header: %s",
e.what());
1631 return btck_Chain::ref(&
WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(),
return btck_ChainstateManager::get(chainman).m_chainman->ActiveChain()));
1637 return btck_Chain::get(chain).Height();
1643 return btck_BlockTreeEntry::ref(btck_Chain::get(chain)[height]);
1649 return btck_Chain::get(chain).Contains(btck_BlockTreeEntry::get(entry)) ? 1 : 0;
1655 auto header{std::make_unique<CBlockHeader>()};
1661 LogError(
"Block header decode failed.");
1665 return btck_BlockHeader::ref(header.release());
1670 return btck_BlockHeader::copy(header);
1675 return btck_BlockHash::create(btck_BlockHeader::get(header).GetHash());
1680 return btck_BlockHash::ref(&btck_BlockHeader::get(header).hashPrevBlock);
1685 std::memcpy(output, btck_BlockHeader::get(header).hashMerkleRoot.begin(), 32);
1690 return btck_BlockHeader::get(header).nTime;
1695 return btck_BlockHeader::get(header).nBits;
1700 return btck_BlockHeader::get(header).nVersion;
1705 return btck_BlockHeader::get(header).nNonce;
1711 SpanWriter{std::as_writable_bytes(std::span{output, 80})} << btck_BlockHeader::get(header);
1725 const auto& state = btck_TxValidationState::get(
state_);
1733 return btck_TxValidationState::create();
1738 switch (btck_TxValidationState::get(
state_).GetResult()) {
int btck_block_to_bytes(const btck_Block *block, btck_WriteBytes writer, void *user_data)
btck_ScriptPubkey * btck_script_pubkey_copy(const btck_ScriptPubkey *script_pubkey)
Copy a script pubkey.
btck_BlockHash * btck_block_hash_copy(const btck_BlockHash *block_hash)
Copy a block hash.
void btck_txid_destroy(btck_Txid *txid)
Destroy the txid.
int btck_script_pubkey_to_bytes(const btck_ScriptPubkey *script_pubkey_, btck_WriteBytes writer, void *user_data)
void btck_script_pubkey_destroy(btck_ScriptPubkey *script_pubkey)
Destroy the script pubkey.
btck_TxValidationResult btck_tx_validation_state_get_tx_validation_result(const btck_TxValidationState *state_)
Returns the validation result from an opaque btck_TxValidationState pointer.
btck_Wtxid * btck_wtxid_copy(const btck_Wtxid *wtxid)
Copy a wtxid.
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)
Triggers the start of a reindex if the wipe options were previously set for the chainstate manager.
const btck_Coin * btck_transaction_spent_outputs_get_coin_at(const btck_TransactionSpentOutputs *transaction_spent_outputs, size_t coin_index)
Returns a coin contained in the transaction spent outputs at a certain index.
const btck_TransactionInput * btck_transaction_get_input_at(const btck_Transaction *transaction, size_t input_index)
Get the transaction input at the provided index.
uint32_t btck_coin_confirmation_height(const btck_Coin *coin)
Returns the block height where the transaction that created this coin was included in.
void btck_context_destroy(btck_Context *context)
Destroy the context.
void btck_context_options_set_notifications(btck_ContextOptions *options, btck_NotificationInterfaceCallbacks notifications)
Set the kernel notifications for the context options.
btck_StringView btck_log_entry_get_function_name(const btck_LogEntry *entry)
Get the name of the function that produced the log statement.
btck_ContextOptions * btck_context_options_create()
Creates an empty context options.
void btck_transaction_destroy(btck_Transaction *transaction)
Destroy the transaction.
btck_PrecomputedTransactionData * btck_precomputed_transaction_data_create(const btck_Transaction *tx_to, const btck_TransactionOutput **spent_outputs_, size_t spent_outputs_len)
Create precomputed transaction data for script verification.
const btck_BlockTreeEntry * btck_block_tree_entry_get_ancestor(const btck_BlockTreeEntry *block_tree_entry, int32_t height)
Return the ancestor of a btck_BlockTreeEntry at the given height.
int64_t btck_transaction_output_get_amount(const btck_TransactionOutput *output)
Get the amount in the output.
void btck_chainstate_manager_options_update_chainstate_db_in_memory(btck_ChainstateManagerOptions *chainman_opts, int chainstate_db_in_memory)
Sets chainstate db in memory in the options.
uint32_t btck_block_header_get_nonce(const btck_BlockHeader *header)
Get the nonce from btck_BlockHeader.
const btck_Txid * btck_transaction_out_point_get_txid(const btck_TransactionOutPoint *out_point)
Get the txid from the transaction out point.
btck_BlockValidationState * btck_block_validation_state_create()
Create a new btck_BlockValidationState.
btck_LogCategory btck_log_entry_get_category(const btck_LogEntry *entry)
Get the category of the log entry.
void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs *transaction_spent_outputs)
Destroy the transaction spent outputs.
const btck_BlockTreeEntry * btck_block_tree_entry_get_previous(const btck_BlockTreeEntry *entry)
Returns the previous block tree entry in the tree, or null if the current block tree entry is the gen...
void btck_chain_parameters_destroy(btck_ChainParameters *chain_parameters)
Destroy the chain parameters.
size_t btck_transaction_count_outputs(const btck_Transaction *transaction)
Get the number of outputs of a transaction.
int btck_witness_stack_get_item_at(const btck_WitnessStack *witness_stack, size_t index, btck_WriteBytes writer, void *user_data)
size_t btck_witness_stack_count_items(const btck_WitnessStack *witness_stack)
Return the number of items in a witness stack.
void btck_block_destroy(btck_Block *block)
Destroy the block.
btck_ScriptPubkey * btck_script_pubkey_create(const void *script_pubkey, size_t script_pubkey_len)
Create a script pubkey from serialized data.
btck_Context * btck_context_copy(const btck_Context *context)
Copy the context.
const btck_BlockTreeEntry * btck_chainstate_manager_get_best_entry(const btck_ChainstateManager *chainstate_manager)
Get the btck_BlockTreeEntry whose associated btck_BlockHeader has the most known cumulative proof of ...
btck_ChainParameters * btck_chain_parameters_create(const btck_ChainType chain_type)
Creates a chain parameters struct with default parameters based on the passed in chain type.
int32_t btck_block_header_get_version(const btck_BlockHeader *header)
Get the version from btck_BlockHeader.
int btck_set_mock_time(int64_t timestamp)
Override the current time with a fixed timestamp for testing.
btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState *block_validation_state_)
Returns the validation mode from an opaque btck_BlockValidationState pointer.
btck_Block * btck_block_create(const void *raw_block, size_t raw_block_length)
Parse a serialized raw block into a new block object.
void btck_chainstate_manager_options_update_block_tree_db_in_memory(btck_ChainstateManagerOptions *chainman_opts, int block_tree_db_in_memory)
Sets block tree db in memory in the options.
static const kernel::Context btck_context_static
void btck_witness_stack_destroy(btck_WitnessStack *witness_stack)
Destroy the witness stack.
btck_ChainParameters * btck_chain_parameters_copy(const btck_ChainParameters *chain_parameters)
Copy the chain parameters.
int btck_block_tree_entry_equals(const btck_BlockTreeEntry *entry1, const btck_BlockTreeEntry *entry2)
uint32_t btck_block_header_get_bits(const btck_BlockHeader *header)
Get the nBits difficulty target from btck_BlockHeader.
const btck_Wtxid * btck_transaction_get_wtxid(const btck_Transaction *transaction)
Get the wtxid of a transaction.
int32_t btck_chain_get_height(const btck_Chain *chain)
Return the height of the tip of the chain.
btck_BlockHeader * btck_block_get_header(const btck_Block *block)
Get the btck_BlockHeader from the block.
size_t btck_block_count_transactions(const btck_Block *block)
Count the number of transactions contained in a block.
int64_t btck_log_entry_get_timestamp_ns(const btck_LogEntry *entry)
Get the wall-clock time when the entry was logged.
void btck_context_options_destroy(btck_ContextOptions *options)
Destroy the context options.
void btck_logging_set_min_level(btck_LogLevel level)
Set the minimum log level.
void btck_block_header_get_merkle_root(const btck_BlockHeader *header, unsigned char output[32])
btck_LoggingConnection * btck_logging_connection_create(btck_LogCallback callback, void *user_data, btck_DestroyCallback user_data_destroy_callback)
Start logging messages through the provided callback.
btck_BlockHeader * btck_block_header_copy(const btck_BlockHeader *header)
Copy a btck_BlockHeader.
int btck_script_pubkey_verify(const btck_ScriptPubkey *script_pubkey, const int64_t amount, const btck_Transaction *tx_to, const btck_PrecomputedTransactionData *precomputed_txdata, const unsigned int input_index, const btck_ScriptVerificationFlags flags, btck_ScriptVerifyStatus *status)
uint32_t btck_log_entry_get_line(const btck_LogEntry *entry)
Get the line number of the source code that produced the log statement.
btck_BlockSpentOutputs * btck_block_spent_outputs_copy(const btck_BlockSpentOutputs *block_spent_outputs)
Copy a block's spent outputs.
void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData *precomputed_txdata)
Destroy the precomputed transaction data.
const btck_TransactionOutPoint * btck_transaction_input_get_out_point(const btck_TransactionInput *input)
Get the transaction out point.
btck_BlockSpentOutputs * btck_block_spent_outputs_read(const btck_ChainstateManager *chainman, const btck_BlockTreeEntry *entry)
void btck_tx_validation_state_destroy(btck_TxValidationState *state)
Destroy the btck_TxValidationState.
btck_ChainstateManager * btck_chainstate_manager_create(const btck_ChainstateManagerOptions *chainman_opts)
Create a chainstate manager.
int btck_transaction_check(const btck_Transaction *tx, btck_TxValidationState *validation_state)
void btck_block_validation_state_destroy(btck_BlockValidationState *state)
Destroy the btck_BlockValidationState.
btck_BlockHash * btck_block_get_hash(const btck_Block *block)
Calculate and return the hash of a block.
btck_Txid * btck_txid_copy(const btck_Txid *txid)
Copy a txid.
const btck_TransactionSpentOutputs * btck_block_spent_outputs_get_transaction_spent_outputs_at(const btck_BlockSpentOutputs *block_spent_outputs, size_t transaction_index)
Returns a transaction spent outputs contained in the block spent outputs at a certain index.
btck_Context * btck_context_create(const btck_ContextOptions *options)
Create a new kernel context.
const btck_TransactionOutput * btck_coin_get_output(const btck_Coin *coin)
Return the transaction output of a coin.
void btck_transaction_out_point_destroy(btck_TransactionOutPoint *out_point)
Destroy the transaction out point.
uint32_t btck_transaction_get_locktime(const btck_Transaction *transaction)
Get a transaction's nLockTime value.
int btck_coin_is_coinbase(const btck_Coin *coin)
Returns whether the containing transaction was a coinbase.
int btck_wtxid_equals(const btck_Wtxid *wtxid1, const btck_Wtxid *wtxid2)
void btck_txid_to_bytes(const btck_Txid *txid, unsigned char output[32])
void btck_block_hash_destroy(btck_BlockHash *hash)
Destroy the block hash.
int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions *chainman_opts, int wipe_block_tree_db, int wipe_chainstate_db)
Sets wipe db in the options.
uint32_t btck_transaction_get_version(const btck_Transaction *transaction)
Get a transaction's version.
btck_BlockHeader * btck_block_tree_entry_get_block_header(const btck_BlockTreeEntry *entry)
Return the btck_BlockHeader associated with this entry.
int btck_context_interrupt(btck_Context *context)
Interrupt can be used to halt long-running validation functions like when reindexing,...
const btck_ConsensusParams * btck_chain_parameters_get_consensus_params(const btck_ChainParameters *chain_parameters)
Get btck_ConsensusParams from btck_ChainParameters.
void btck_transaction_input_destroy(btck_TransactionInput *input)
Destroy the transaction input.
const btck_TransactionOutput * btck_transaction_get_output_at(const btck_Transaction *transaction, size_t output_index)
Get the transaction outputs at the provided index.
const btck_BlockTreeEntry * btck_chain_get_by_height(const btck_Chain *chain, int32_t height)
Retrieve a block tree entry by its height in the currently active chain.
void btck_coin_destroy(btck_Coin *coin)
Destroy the coin.
void btck_context_options_set_chainparams(btck_ContextOptions *options, const btck_ChainParameters *chain_parameters)
btck_WitnessStack * btck_witness_stack_copy(const btck_WitnessStack *witness_stack)
Copy a witness stack.
int btck_block_header_to_bytes(const btck_BlockHeader *header, unsigned char output[80])
int64_t btck_log_entry_get_mocktime_s(const btck_LogEntry *entry)
Get the mock time in effect when the entry was logged.
int btck_chainstate_manager_options_set_database_cache_bytes(btck_ChainstateManagerOptions *chainman_opts, uint64_t database_cache_bytes)
Set the total database cache used by the chainstate manager.
const btck_WitnessStack * btck_transaction_input_get_witness_stack(const btck_TransactionInput *input)
Get the witness stack of a transaction input.
btck_BlockHeader * btck_block_header_create(const void *raw_block_header, size_t raw_block_header_len)
Create a btck_BlockHeader from serialized data.
uint32_t btck_block_header_get_timestamp(const btck_BlockHeader *header)
Get the timestamp from btck_BlockHeader.
btck_ChainParameters * btck_chain_parameters_create_signet(const void *challenge, size_t challenge_len)
Create a signet chain parameters struct with a user-provided challenge.
void btck_block_header_destroy(btck_BlockHeader *header)
Destroy the btck_BlockHeader.
btck_PrecomputedTransactionData * btck_precomputed_transaction_data_copy(const btck_PrecomputedTransactionData *precomputed_txdata)
Copy precomputed transaction data.
btck_BlockHash * btck_block_hash_create(const unsigned char block_hash[32])
Create a block hash from its raw data.
btck_BlockHash * btck_block_header_get_hash(const btck_BlockHeader *header)
Get the btck_BlockHash.
btck_LogLevel btck_log_entry_get_level(const btck_LogEntry *entry)
Get the severity level of the log entry.
const TranslateFn G_TRANSLATION_FUN
btck_ValidationMode btck_tx_validation_state_get_validation_mode(const btck_TxValidationState *state_)
Returns the validation mode from an opaque btck_TxValidationState pointer.
void btck_wtxid_to_bytes(const btck_Wtxid *wtxid, unsigned char output[32])
int btck_transaction_input_get_script_sig(const btck_TransactionInput *input, btck_WriteBytes writer, void *user_data)
int btck_transaction_has_witness(const btck_Transaction *transaction)
Check whether a transaction has witness data.
void btck_context_options_set_validation_interface(btck_ContextOptions *options, btck_ValidationInterfaceCallbacks vi_cbs)
Set the validation interface callbacks for the context options.
uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint *out_point)
Get the output position from the transaction out point.
const btck_BlockHash * btck_block_header_get_prev_hash(const btck_BlockHeader *header)
Get the previous btck_BlockHash from btck_BlockHeader.
btck_Block * btck_block_read(const btck_ChainstateManager *chainman, const btck_BlockTreeEntry *entry)
const btck_Txid * btck_transaction_get_txid(const btck_Transaction *transaction)
Get the txid of a transaction.
btck_TransactionOutPoint * btck_transaction_out_point_copy(const btck_TransactionOutPoint *out_point)
Copy a transaction out point.
btck_BlockValidationState * btck_chainstate_manager_process_block_header(btck_ChainstateManager *chainstate_manager, const btck_BlockHeader *header)
btck_TransactionInput * btck_transaction_input_copy(const btck_TransactionInput *input)
Copy a transaction input.
int btck_chain_contains(const btck_Chain *chain, const btck_BlockTreeEntry *entry)
const btck_BlockTreeEntry * btck_chainstate_manager_get_block_tree_entry_by_hash(const btck_ChainstateManager *chainman, const btck_BlockHash *block_hash)
void btck_wtxid_destroy(btck_Wtxid *wtxid)
Destroy the wtxid.
size_t btck_block_spent_outputs_count(const btck_BlockSpentOutputs *block_spent_outputs)
Returns the number of transaction spent outputs whose data is contained in block spent outputs.
btck_TransactionOutput * btck_transaction_output_copy(const btck_TransactionOutput *output)
Copy a transaction output.
int btck_block_hash_equals(const btck_BlockHash *hash1, const btck_BlockHash *hash2)
void btck_logging_connection_destroy(btck_LoggingConnection *connection)
Stop logging and destroy the logging connection.
btck_TransactionSpentOutputs * btck_transaction_spent_outputs_copy(const btck_TransactionSpentOutputs *transaction_spent_outputs)
Copy a transaction's spent outputs.
int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry *entry)
Return the height of a certain block tree entry.
void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs *block_spent_outputs)
Destroy the block spent outputs.
const btck_ScriptPubkey * btck_transaction_output_get_script_pubkey(const btck_TransactionOutput *output)
Get the script pubkey of the output.
int btck_chainstate_manager_process_block(btck_ChainstateManager *chainman, const btck_Block *block, int *_new_block)
size_t btck_transaction_count_inputs(const btck_Transaction *transaction)
Get the number of inputs of a transaction.
int btck_block_check(const btck_Block *block, const btck_ConsensusParams *consensus_params, btck_BlockCheckFlags flags, btck_BlockValidationState *validation_state)
int btck_txid_equals(const btck_Txid *txid1, const btck_Txid *txid2)
btck_Block * btck_block_copy(const btck_Block *block)
Copy a block.
void btck_chainstate_manager_destroy(btck_ChainstateManager *chainman)
Destroy the chainstate manager.
void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions *options)
Destroy the chainstate manager options.
btck_Transaction * btck_transaction_create(const void *raw_transaction, size_t raw_transaction_len)
Create a new transaction from the serialized data.
btck_Coin * btck_coin_copy(const btck_Coin *coin)
Copy a coin.
const btck_BlockHash * btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry *entry)
Return the block hash associated with a block tree entry.
void btck_chainstate_manager_options_set_worker_threads_num(btck_ChainstateManagerOptions *opts, int worker_threads)
Set the number of available worker threads used during validation.
int btck_transaction_to_bytes(const btck_Transaction *transaction, btck_WriteBytes writer, void *user_data)
btck_TransactionOutput * btck_transaction_output_create(const btck_ScriptPubkey *script_pubkey, int64_t amount)
Create a transaction output from a script pubkey and an amount.
btck_Transaction * btck_transaction_copy(const btck_Transaction *transaction)
Copy a transaction.
btck_StringView btck_log_entry_get_message(const btck_LogEntry *entry)
Get the message text from a btck_LogEntry.
btck_TxValidationState * btck_tx_validation_state_create()
Create a new btck_TxValidationState.
const btck_Transaction * btck_block_get_transaction_at(const btck_Block *block, size_t index)
Get the transaction at the provided index.
const btck_Chain * btck_chainstate_manager_get_active_chain(const btck_ChainstateManager *chainman)
Returns the best known currently active chain.
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)
Create options for the chainstate manager.
btck_StringView btck_log_entry_get_file_name(const btck_LogEntry *entry)
Get the name of the source file that produced the log statement.
btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState *block_validation_state_)
Returns the validation result from an opaque btck_BlockValidationState pointer.
btck_BlockValidationState * btck_block_validation_state_copy(const btck_BlockValidationState *state)
Copies the btck_BlockValidationState.
void btck_block_hash_to_bytes(const btck_BlockHash *block_hash, unsigned char output[32])
uint32_t btck_transaction_input_get_sequence(const btck_TransactionInput *input)
Get a transaction input's nSequence value.
void btck_transaction_output_destroy(btck_TransactionOutput *output)
Destroy the transaction output.
btck_StringView btck_log_entry_get_thread_name(const btck_LogEntry *entry)
Get the name of the thread that produced the log message.
size_t btck_transaction_spent_outputs_count(const btck_TransactionSpentOutputs *transaction_spent_outputs)
Returns the number of previous transaction outputs contained in the transaction spent outputs data.
#define btck_ChainType_REGTEST
uint8_t btck_LogLevel
The severity of a log statement.
#define btck_TxValidationResult_NOT_STANDARD
otherwise didn't meet local policy rules
#define btck_TxValidationResult_CONFLICT
tx already in mempool or conflicts with a tx in the chain
#define btck_LogLevel_WARNING
int(* btck_WriteBytes)(const void *bytes, size_t size, void *userdata)
Function signature for serializing data.
#define btck_TxValidationResult_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
uint32_t btck_TxValidationResult
Indicates the reason why a transaction failed validation.
#define btck_ChainType_MAINNET
#define btck_BlockValidationResult_HEADER_LOW_WORK
the block header may be on a too-little-work chain
#define btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED
#define btck_TxValidationResult_MISSING_INPUTS
transaction was missing some of its inputs
#define btck_BlockValidationResult_INVALID_PREV
A block this one builds on is invalid.
#define btck_BlockCheckFlags_MERKLE
verify merkle root (and mutation detection)
#define btck_LogCategory_MEMPOOL
#define btck_TxValidationResult_UNKNOWN
transaction was not validated because package failed
#define btck_LogLevel_TRACE
#define btck_ChainType_TESTNET
#define btck_SynchronizationState_INIT_REINDEX
#define btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION
The flags were combined in an invalid way.
uint32_t btck_BlockValidationResult
A granular "reason" why a block was invalid.
#define btck_LogCategory_BENCH
uint8_t btck_ValidationMode
Whether a validated data structure is valid, invalid, or an error was encountered during processing.
#define btck_ScriptVerificationFlags_ALL
void(* btck_LogCallback)(void *user_data, const btck_LogEntry *entry)
Callback function types.
#define btck_LogCategory_LOCK
#define btck_LogCategory_PRUNE
uint8_t btck_SynchronizationState
Current sync state passed to tip changed callbacks.
#define btck_ChainType_TESTNET_4
#define btck_LogCategory_COINDB
#define btck_TxValidationResult_NO_MEMPOOL
this node does not have a mempool so can't validate the transaction
#define btck_ScriptVerificationFlags_TAPROOT
enable TAPROOT (BIPs 341 & 342)
#define btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED
The taproot flag was set, so valid spent_outputs have to be provided.
#define btck_BlockCheckFlags_POW
run CheckProofOfWork via CheckBlockHeader
void(* btck_DestroyCallback)(void *user_data)
Function signature for freeing user data.
uint32_t btck_ScriptVerificationFlags
Script verification flags that may be composed with each other.
#define btck_LogCategory_VALIDATION
#define btck_LogCategory_REINDEX
#define btck_LogLevel_DEBUG
#define btck_ScriptVerifyStatus_OK
#define btck_TxValidationResult_WITNESS_STRIPPED
transaction is missing a witness
#define btck_LogCategory_RAND
#define btck_TxValidationResult_INPUTS_NOT_STANDARD
inputs (covered by txid) failed policy rules
#define btck_BlockValidationResult_CONSENSUS
invalid by consensus rules (excluding any below reasons)
#define btck_BlockValidationResult_UNSET
initial value. Block has not yet been rejected
#define btck_TxValidationResult_UNSET
initial value. Tx has not yet been rejected
#define btck_SynchronizationState_POST_INIT
#define btck_BlockValidationResult_MISSING_PREV
We don't have the previous block the checked one is built on.
uint8_t btck_ScriptVerifyStatus
A collection of status codes that may be issued by the script verify function.
#define btck_ValidationMode_INTERNAL_ERROR
#define btck_TxValidationResult_WITNESS_MUTATED
witness may have been malleated or is prior to SegWit activation
uint8_t btck_LogCategory
A collection of logging categories that may be encountered by kernel code.
#define btck_ValidationMode_INVALID
#define btck_ChainType_SIGNET
#define btck_TxValidationResult_CONSENSUS
invalid by consensus rules
uint32_t btck_BlockCheckFlags
Bitflags to control context-free block checks (optional).
#define btck_BlockValidationResult_INVALID_HEADER
invalid proof of work or time too old
uint8_t btck_Warning
Possible warning types issued by validation.
#define btck_LogCategory_NONE
Not tied to a specific category, e.g. most INFO, WARNING and ERROR entries.
#define btck_BlockValidationResult_TIME_FUTURE
block timestamp was > 2 hours in the future (or our clock is bad)
#define btck_LogCategory_LEVELDB
#define btck_LogLevel_ERROR
#define btck_BlockValidationResult_CACHED_INVALID
this block was cached as being invalid and we didn't store the reason why
#define btck_Warning_LARGE_WORK_INVALID_CHAIN
#define btck_LogLevel_INFO
#define btck_TxValidationResult_PREMATURE_SPEND
transaction spends a coinbase too early, or violates locktime/sequence locks
#define btck_LogCategory_BLOCKSTORAGE
#define btck_ValidationMode_VALID
#define btck_LogCategory_KERNEL
#define btck_BlockValidationResult_MUTATED
the block's data didn't match the data committed to by the PoW
#define btck_LogCategory_TXPACKAGES
#define btck_TxValidationResult_MEMPOOL_POLICY
violated mempool's fee/size/descendant/RBF/etc limits
#define btck_SynchronizationState_INIT_DOWNLOAD
const CChainParams & Params()
Return the currently selected parameters.
#define Assume(val)
Assume is the identity function.
The block chain is a tree shaped structure starting with the genesis block at the root,...
CChainParams defines various tweakable parameters of a given instance of the Bitcoin system.
static std::unique_ptr< const CChainParams > TestNet4()
static std::unique_ptr< const CChainParams > Main()
static std::unique_ptr< const CChainParams > TestNet()
static std::unique_ptr< const CChainParams > SigNet()
static std::unique_ptr< const CChainParams > RegTest()
The basic transaction that is broadcasted on the network and contained in blocks.
const std::vector< CTxOut > vout
An output of a transaction.
Implement this to subscribe to events generated in validation and mempool.
virtual void NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr< const CBlock > &block)
Notifies listeners that a block which builds directly on our current tip has been received and connec...
virtual void BlockChecked(const std::shared_ptr< const CBlock > &, const BlockValidationState &)
Notifies listeners of a block validation result.
virtual void BlockDisconnected(const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being disconnected Provides the block that was disconnected.
virtual void BlockConnected(const kernel::ChainstateRole &role, const std::shared_ptr< const CBlock > &block, const CBlockIndex *pindex)
Notifies listeners of a block being connected.
Interface for managing multiple Chainstate objects, where each chainstate is associated with chainsta...
Minimal stream for reading from an existing byte array by std::span.
Minimal stream for writing to an existing span of bytes.
void RegisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Register subscriber.
void UnregisterSharedValidationInterface(std::shared_ptr< CValidationInterface > callbacks)
Unregister subscriber.
A base class defining functions for notifying about certain kernel events.
virtual void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync)
virtual void fatalError(const bilingual_str &message)
The fatal error notification is sent to notify the user when an error occurs in kernel code that can'...
virtual void warningSet(Warning id, const bilingual_str &message)
virtual void progress(const bilingual_str &title, int progress_percent, bool resume_possible)
virtual InterruptResult blockTip(SynchronizationState state, const CBlockIndex &index, double verification_progress)
virtual void flushError(const bilingual_str &message)
The flush error notification is sent to notify the user that an error occurred while flushing block d...
virtual void warningUnset(Warning id)
static constexpr script_verify_flags from_int(value_type f)
static const PrecomputedData data
Precomputed COutPoint and CCoins values.
@ BLOCK_HEADER_LOW_WORK
the block header may be on a too-little-work chain
@ BLOCK_INVALID_HEADER
invalid proof of work or time too old
@ BLOCK_CACHED_INVALID
this block was cached as being invalid and we didn't store the reason why
@ BLOCK_CONSENSUS
invalid by consensus rules (excluding any below reasons)
@ BLOCK_MISSING_PREV
We don't have the previous block the checked one is built on.
@ BLOCK_INVALID_PREV
A block this one builds on is invalid.
@ BLOCK_MUTATED
the block's data didn't match the data committed to by the PoW
@ BLOCK_TIME_FUTURE
block timestamp was > 2 hours in the future (or our clock is bad)
@ BLOCK_RESULT_UNSET
initial value. Block has not yet been rejected
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
@ TX_MEMPOOL_POLICY
violated mempool's fee/size/descendant/RBF/etc limits
@ TX_UNKNOWN
transaction was not validated because package failed
@ TX_PREMATURE_SPEND
transaction spends a coinbase too early, or violates locktime/sequence locks
@ TX_INPUTS_NOT_STANDARD
inputs (covered by txid) failed policy rules
@ TX_WITNESS_STRIPPED
Transaction is missing a witness.
@ TX_CONFLICT
Tx already in mempool or conflicts with a tx in the chain (if it conflicts with another tx in mempool...
@ TX_NOT_STANDARD
otherwise didn't meet our local policy rules
@ TX_WITNESS_MUTATED
Transaction might have a witness prior to SegWit activation, or witness may have been malleated (whic...
@ TX_NO_MEMPOOL
this node does not have a mempool so can't validate the transaction
@ TX_RESULT_UNSET
initial value. Tx has not yet been rejected
@ TX_CONSENSUS
invalid by consensus rules
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
static path absolute(const path &p)
static path PathFromString(const std::string &string)
Convert byte string to path object.
static OutputStream & operator<<(OutputStream &os, const Array &array)
#define T(expected, seed, data)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, script_verify_flags flags, const BaseSignatureChecker &checker, ScriptError *serror)
@ FAIL
Just act as if the signature was invalid.
@ SCRIPT_VERIFY_CLEANSTACK
constexpr uint64_t MAX_DBCACHE_BYTES
Maximum total database cache on current architecture (bytes)
constexpr uint64_t DEFAULT_KERNEL_CACHE
Suggested default amount of cache reserved for the kernel (bytes)
#define LogDebug(category,...)
Transaction validation functions.
std::variant< std::monostate, Interrupted > InterruptResult
Simple result type for functions that need to propagate an interrupt status and don't have other retu...
@ UNKNOWN_NEW_RULES_ACTIVATED
@ LARGE_WORK_INVALID_CHAIN
util::Result< void > SanityChecks(const Context &)
Ensure a usable environment with all necessary library support.
Log
Log flags. Update stringify function if changed!
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
void ImportBlocks(ChainstateManager &chainman, std::span< const fs::path > import_paths)
void Log(Entry entry)
Send message to be logged.
bool ShouldDebugLog(Category)
Return whether messages with specified category should be debug logged.
bool ShouldTraceLog(Category)
Return whether messages with specified category should be trace logged.
uint64_t Category
Opaque to util::log; interpreted by consumers (e.g., BCLog::LogFlags).
bilingual_str ErrorString(const Result< T > &result)
std::string_view RemoveSuffixView(std::string_view str LIFETIMEBOUND, std::string_view suffix)
ValidationSignals & m_signals
std::shared_ptr< Chain::Notifications > m_notifications
constexpr TransactionSerParams TX_WITH_WITNESS
void Serialize(Stream &, V)=delete
constexpr deserialize_type deserialize
SigNetOptions holds configurations for creating a signet CChainParams.
Application-specific storage settings.
A struct for holding the kernel notification callbacks.
btck_NotifyWarningUnset warning_unset
A previous condition leading to the issuance of a warning is no longer given.
btck_NotifyBlockTip block_tip
The chain's tip was updated to the provided block entry.
btck_NotifyWarningSet warning_set
A warning issued by the kernel library during validation.
btck_NotifyFlushError flush_error
An error encountered when flushing data to disk.
btck_NotifyProgress progress
Reports on current block synchronization progress.
btck_NotifyFatalError fatal_error
An unrecoverable system error encountered by the library.
btck_DestroyCallback user_data_destroy
Frees the provided user data structure.
void * user_data
Holds a user-defined opaque structure that is passed to the notification callbacks.
btck_NotifyHeaderTip header_tip
A new best block header was added.
A non-owning view of a string.
Holds the validation interface callbacks.
btck_DestroyCallback user_data_destroy
Frees the provided user data structure.
btck_ValidationInterfaceBlockConnected block_connected
Called when a block is valid and has now been connected to the best chain.
btck_ValidationInterfaceBlockChecked block_checked
Called when a new block has been fully validated.
btck_ValidationInterfaceBlockDisconnected block_disconnected
Called during a re-org when a block has been removed from the best chain.
void * user_data
Holds a user-defined opaque structure that is passed to the validation interface callbacks.
btck_ValidationInterfacePoWValidBlock pow_valid_block
Called when a new block extends the header chain and has a valid transaction and segwit merkle root.
An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to th...
An options struct for ChainstateManager, more ergonomically referred to as ChainstateManager::Options...
Information about chainstate that notifications are sent from.
Context struct holding the kernel library's logically global state, and passed to external libbitcoin...
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
This header provides an interface and simple implementation for a task runner.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
std::function< std::string(const char *)> TranslateFn
Translate a message to the native language of the user.
bool CheckTransaction(const CTransaction &tx, TxValidationState &state)
void SetMockTime(std::chrono::time_point< NodeClock, std::chrono::seconds > mock)
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
bool CheckBlock(const CBlock &block, BlockValidationState &state, const Consensus::Params &consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
Functions for validating blocks and updating the block tree.
SynchronizationState
Current sync state passed to tip changed callbacks.