kernel-docs/bitcoinkernel_8h_source.html

// Copyright (c) 2024-present The Bitcoin Core developers

// Distributed under the MIT software license, see the accompanying

// file COPYING or http://www.opensource.org/licenses/mit-license.php.


#ifndef BITCOIN_KERNEL_BITCOINKERNEL_H

#define BITCOIN_KERNEL_BITCOINKERNEL_H


#ifndef __cplusplus

#include <stddef.h>

#include <stdint.h>

#else

#include <cstddef>

#include <cstdint>

#endif // __cplusplus


#ifndef BITCOINKERNEL_API

    #ifdef BITCOINKERNEL_BUILD

        #if defined(_WIN32)

            #define BITCOINKERNEL_API __declspec(dllexport)

        #else

            #define BITCOINKERNEL_API __attribute__((visibility("default")))

        #endif

    #else

        #if defined(_WIN32) && !defined(BITCOINKERNEL_STATIC)

            #define BITCOINKERNEL_API __declspec(dllimport)

        #else

            #define BITCOINKERNEL_API

        #endif

    #endif

#endif


/* Warning attributes */

#if defined(__GNUC__)

    #define BITCOINKERNEL_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))

#else

    #define BITCOINKERNEL_WARN_UNUSED_RESULT

#endif


#if !defined(BITCOINKERNEL_BUILD) && defined(__GNUC__)

    #define BITCOINKERNEL_ARG_NONNULL(...) __attribute__((__nonnull__(__VA_ARGS__)))

#else

    #define BITCOINKERNEL_ARG_NONNULL(...)

#endif


#ifdef __cplusplus

extern "C" {

#endif // __cplusplus


typedef struct btck_Transaction btck_Transaction;


typedef struct btck_ScriptPubkey btck_ScriptPubkey;


typedef struct btck_TransactionOutput btck_TransactionOutput;


typedef struct btck_LoggingConnection btck_LoggingConnection;


typedef struct btck_ChainParameters btck_ChainParameters;


typedef struct btck_ContextOptions btck_ContextOptions;


typedef struct btck_Context btck_Context;


typedef struct btck_BlockTreeEntry btck_BlockTreeEntry;


typedef struct btck_ChainstateManagerOptions btck_ChainstateManagerOptions;


typedef struct btck_ChainstateManager btck_ChainstateManager;


typedef struct btck_Block btck_Block;


typedef struct btck_BlockValidationState btck_BlockValidationState;


typedef struct btck_Chain btck_Chain;


typedef struct btck_BlockSpentOutputs btck_BlockSpentOutputs;


typedef struct btck_TransactionSpentOutputs btck_TransactionSpentOutputs;


typedef struct btck_Coin btck_Coin;


typedef struct btck_BlockHash btck_BlockHash;


typedef struct btck_TransactionInput btck_TransactionInput;


typedef struct btck_TransactionOutPoint btck_TransactionOutPoint;


typedef struct btck_PrecomputedTransactionData btck_PrecomputedTransactionData;


typedef struct btck_Txid btck_Txid;


typedef struct btck_BlockHeader btck_BlockHeader;


typedef uint8_t btck_SynchronizationState;

#define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))

#define btck_SynchronizationState_INIT_DOWNLOAD ((btck_SynchronizationState)(1))

#define btck_SynchronizationState_POST_INIT ((btck_SynchronizationState)(2))


typedef uint8_t btck_Warning;

#define btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED ((btck_Warning)(0))

#define btck_Warning_LARGE_WORK_INVALID_CHAIN ((btck_Warning)(1))


typedef void (*btck_LogCallback)(void* user_data, const char* message, size_t message_len);


typedef void (*btck_DestroyCallback)(void* user_data);


typedef void (*btck_NotifyBlockTip)(void* user_data, btck_SynchronizationState state, const btck_BlockTreeEntry* entry, double verification_progress);

typedef void (*btck_NotifyHeaderTip)(void* user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync);

typedef void (*btck_NotifyProgress)(void* user_data, const char* title, size_t title_len, int progress_percent, int resume_possible);

typedef void (*btck_NotifyWarningSet)(void* user_data, btck_Warning warning, const char* message, size_t message_len);

typedef void (*btck_NotifyWarningUnset)(void* user_data, btck_Warning warning);

typedef void (*btck_NotifyFlushError)(void* user_data, const char* message, size_t message_len);

typedef void (*btck_NotifyFatalError)(void* user_data, const char* message, size_t message_len);


typedef void (*btck_ValidationInterfaceBlockChecked)(void* user_data, btck_Block* block, const btck_BlockValidationState* state);

typedef void (*btck_ValidationInterfacePoWValidBlock)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);

typedef void (*btck_ValidationInterfaceBlockConnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);

typedef void (*btck_ValidationInterfaceBlockDisconnected)(void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry);


typedef int (*btck_WriteBytes)(const void* bytes, size_t size, void* userdata);


typedef uint8_t btck_ValidationMode;

#define btck_ValidationMode_VALID ((btck_ValidationMode)(0))

#define btck_ValidationMode_INVALID ((btck_ValidationMode)(1))

#define btck_ValidationMode_INTERNAL_ERROR ((btck_ValidationMode)(2))


typedef uint32_t btck_BlockValidationResult;

#define btck_BlockValidationResult_UNSET ((btck_BlockValidationResult)(0))

#define btck_BlockValidationResult_CONSENSUS ((btck_BlockValidationResult)(1))

#define btck_BlockValidationResult_CACHED_INVALID ((btck_BlockValidationResult)(2))

#define btck_BlockValidationResult_INVALID_HEADER ((btck_BlockValidationResult)(3))

#define btck_BlockValidationResult_MUTATED ((btck_BlockValidationResult)(4))

#define btck_BlockValidationResult_MISSING_PREV ((btck_BlockValidationResult)(5))

#define btck_BlockValidationResult_INVALID_PREV ((btck_BlockValidationResult)(6))

#define btck_BlockValidationResult_TIME_FUTURE ((btck_BlockValidationResult)(7))

#define btck_BlockValidationResult_HEADER_LOW_WORK ((btck_BlockValidationResult)(8))


typedef struct {

    void* user_data;

    btck_DestroyCallback user_data_destroy;

    btck_ValidationInterfaceBlockChecked block_checked;

    btck_ValidationInterfacePoWValidBlock pow_valid_block;

    btck_ValidationInterfaceBlockConnected block_connected;

    btck_ValidationInterfaceBlockDisconnected block_disconnected;

} btck_ValidationInterfaceCallbacks;


typedef struct {

    void* user_data;

    btck_DestroyCallback user_data_destroy;

    btck_NotifyBlockTip block_tip;

    btck_NotifyHeaderTip header_tip;

    btck_NotifyProgress progress;

    btck_NotifyWarningSet warning_set;

    btck_NotifyWarningUnset warning_unset;

    btck_NotifyFlushError flush_error;

    btck_NotifyFatalError fatal_error;

} btck_NotificationInterfaceCallbacks;


typedef uint8_t btck_LogCategory;

#define btck_LogCategory_ALL ((btck_LogCategory)(0))

#define btck_LogCategory_BENCH ((btck_LogCategory)(1))

#define btck_LogCategory_BLOCKSTORAGE ((btck_LogCategory)(2))

#define btck_LogCategory_COINDB ((btck_LogCategory)(3))

#define btck_LogCategory_LEVELDB ((btck_LogCategory)(4))

#define btck_LogCategory_MEMPOOL ((btck_LogCategory)(5))

#define btck_LogCategory_PRUNE ((btck_LogCategory)(6))

#define btck_LogCategory_RAND ((btck_LogCategory)(7))

#define btck_LogCategory_REINDEX ((btck_LogCategory)(8))

#define btck_LogCategory_VALIDATION ((btck_LogCategory)(9))

#define btck_LogCategory_KERNEL ((btck_LogCategory)(10))


typedef uint8_t btck_LogLevel;

#define btck_LogLevel_TRACE ((btck_LogLevel)(0))

#define btck_LogLevel_DEBUG ((btck_LogLevel)(1))

#define btck_LogLevel_INFO ((btck_LogLevel)(2))


typedef struct {

    int log_timestamps;

    int log_time_micros;

    int log_threadnames;

    int log_sourcelocations;

    int always_print_category_levels;

} btck_LoggingOptions;


typedef uint8_t btck_ScriptVerifyStatus;

#define btck_ScriptVerifyStatus_OK ((btck_ScriptVerifyStatus)(0))

#define btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION ((btck_ScriptVerifyStatus)(1))

#define btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED ((btck_ScriptVerifyStatus)(2))


typedef uint32_t btck_ScriptVerificationFlags;

#define btck_ScriptVerificationFlags_NONE ((btck_ScriptVerificationFlags)(0))

#define btck_ScriptVerificationFlags_P2SH ((btck_ScriptVerificationFlags)(1U << 0))

#define btck_ScriptVerificationFlags_DERSIG ((btck_ScriptVerificationFlags)(1U << 2))

#define btck_ScriptVerificationFlags_NULLDUMMY ((btck_ScriptVerificationFlags)(1U << 4))

#define btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY ((btck_ScriptVerificationFlags)(1U << 9))

#define btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY ((btck_ScriptVerificationFlags)(1U << 10))

#define btck_ScriptVerificationFlags_WITNESS ((btck_ScriptVerificationFlags)(1U << 11))

#define btck_ScriptVerificationFlags_TAPROOT ((btck_ScriptVerificationFlags)(1U << 17))


#define btck_ScriptVerificationFlags_ALL ((btck_ScriptVerificationFlags)(btck_ScriptVerificationFlags_P2SH |                \

                                                                         btck_ScriptVerificationFlags_DERSIG |              \

                                                                         btck_ScriptVerificationFlags_NULLDUMMY |           \

                                                                         btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY | \

                                                                         btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY | \

                                                                         btck_ScriptVerificationFlags_WITNESS |             \

                                                                         btck_ScriptVerificationFlags_TAPROOT))


typedef uint8_t btck_ChainType;

#define btck_ChainType_MAINNET ((btck_ChainType)(0))

#define btck_ChainType_TESTNET ((btck_ChainType)(1))

#define btck_ChainType_TESTNET_4 ((btck_ChainType)(2))

#define btck_ChainType_SIGNET ((btck_ChainType)(3))

#define btck_ChainType_REGTEST ((btck_ChainType)(4))


BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_create(

    const void* raw_transaction, size_t raw_transaction_len);


BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_copy(

    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int btck_transaction_to_bytes(

    const btck_Transaction* transaction,

    btck_WriteBytes writer,

    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count_outputs(

    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_output_at(

    const btck_Transaction* transaction, size_t output_index) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_TransactionInput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_input_at(

    const btck_Transaction* transaction, size_t input_index) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_count_inputs(

    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_get_txid(

    const btck_Transaction* transaction) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_transaction_destroy(btck_Transaction* transaction);


BITCOINKERNEL_API btck_PrecomputedTransactionData* BITCOINKERNEL_WARN_UNUSED_RESULT btck_precomputed_transaction_data_create(

    const btck_Transaction* tx_to,

    const btck_TransactionOutput** spent_outputs, size_t spent_outputs_len) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_PrecomputedTransactionData* BITCOINKERNEL_WARN_UNUSED_RESULT btck_precomputed_transaction_data_copy(

    const btck_PrecomputedTransactionData* precomputed_txdata) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData* precomputed_txdata);


BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_create(

    const void* script_pubkey, size_t script_pubkey_len);


BITCOINKERNEL_API btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_copy(

    const btck_ScriptPubkey* script_pubkey) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_script_pubkey_verify(

    const btck_ScriptPubkey* script_pubkey,

    int64_t amount,

    const btck_Transaction* tx_to,

    const btck_PrecomputedTransactionData* precomputed_txdata,

    unsigned int input_index,

    btck_ScriptVerificationFlags flags,

    btck_ScriptVerifyStatus* status) BITCOINKERNEL_ARG_NONNULL(1, 3);


BITCOINKERNEL_API int btck_script_pubkey_to_bytes(

    const btck_ScriptPubkey* script_pubkey,

    btck_WriteBytes writer,

    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_script_pubkey_destroy(btck_ScriptPubkey* script_pubkey);


BITCOINKERNEL_API btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_create(

    const btck_ScriptPubkey* script_pubkey,

    int64_t amount) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_ScriptPubkey* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_get_script_pubkey(

    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int64_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_get_amount(

    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_output_copy(

    const btck_TransactionOutput* transaction_output) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput* transaction_output);


BITCOINKERNEL_API void btck_logging_disable();


BITCOINKERNEL_API void btck_logging_set_options(btck_LoggingOptions options);


BITCOINKERNEL_API void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level);


BITCOINKERNEL_API void btck_logging_enable_category(btck_LogCategory category);


BITCOINKERNEL_API void btck_logging_disable_category(btck_LogCategory category);


BITCOINKERNEL_API btck_LoggingConnection* BITCOINKERNEL_WARN_UNUSED_RESULT btck_logging_connection_create(

    btck_LogCallback log_callback,

    void* user_data,

    btck_DestroyCallback user_data_destroy_callback) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection* logging_connection);


BITCOINKERNEL_API btck_ChainParameters* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_parameters_create(

    btck_ChainType chain_type);


BITCOINKERNEL_API btck_ChainParameters* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_parameters_copy(

    const btck_ChainParameters* chain_parameters) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters);


BITCOINKERNEL_API btck_ContextOptions* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_options_create();


BITCOINKERNEL_API void btck_context_options_set_chainparams(

    btck_ContextOptions* context_options,

    const btck_ChainParameters* chain_parameters) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_context_options_set_notifications(

    btck_ContextOptions* context_options,

    btck_NotificationInterfaceCallbacks notifications) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_context_options_set_validation_interface(

    btck_ContextOptions* context_options,

    btck_ValidationInterfaceCallbacks validation_interface_callbacks) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_context_options_destroy(btck_ContextOptions* context_options);


BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_create(

    const btck_ContextOptions* context_options);


BITCOINKERNEL_API btck_Context* BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_copy(

    const btck_Context* context) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_context_interrupt(

    btck_Context* context) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_context_destroy(btck_Context* context);


BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_previous(

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_header(

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_height(

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_hash(

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_equals(

    const btck_BlockTreeEntry* entry1, const btck_BlockTreeEntry* entry2) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API btck_ChainstateManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_options_create(

    const btck_Context* context,

    const char* data_directory,

    size_t data_directory_len,

    const char* blocks_directory,

    size_t blocks_directory_len) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_chainstate_manager_options_set_worker_threads_num(

    btck_ChainstateManagerOptions* chainstate_manager_options,

    int worker_threads) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_options_set_wipe_dbs(

    btck_ChainstateManagerOptions* chainstate_manager_options,

    int wipe_block_tree_db,

    int wipe_chainstate_db) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_chainstate_manager_options_update_block_tree_db_in_memory(

    btck_ChainstateManagerOptions* chainstate_manager_options,

    int block_tree_db_in_memory) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_chainstate_manager_options_update_chainstate_db_in_memory(

    btck_ChainstateManagerOptions* chainstate_manager_options,

    int chainstate_db_in_memory) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* chainstate_manager_options);


BITCOINKERNEL_API btck_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_create(

    const btck_ChainstateManagerOptions* chainstate_manager_options) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_best_entry(

    const btck_ChainstateManager* chainstate_manager) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_process_block_header(

    btck_ChainstateManager* chainstate_manager,

    const btck_BlockHeader* header,

    btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_import_blocks(

    btck_ChainstateManager* chainstate_manager,

    const char** block_file_paths_data, size_t* block_file_paths_lens,

    size_t block_file_paths_data_len) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_process_block(

    btck_ChainstateManager* chainstate_manager,

    const btck_Block* block,

    int* new_block) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);


BITCOINKERNEL_API const btck_Chain* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_active_chain(

    const btck_ChainstateManager* chainstate_manager) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chainstate_manager_get_block_tree_entry_by_hash(

    const btck_ChainstateManager* chainstate_manager,

    const btck_BlockHash* block_hash) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_chainstate_manager_destroy(btck_ChainstateManager* chainstate_manager);


BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_read(

    const btck_ChainstateManager* chainstate_manager,

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_create(

    const void* raw_block, size_t raw_block_len);


BITCOINKERNEL_API btck_Block* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_copy(

    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_count_transactions(

    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_transaction_at(

    const btck_Block* block, size_t transaction_index) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_header(

    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_get_hash(

    const btck_Block* block) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int btck_block_to_bytes(

    const btck_Block* block,

    btck_WriteBytes writer,

    void* user_data) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_block_destroy(btck_Block* block);


BITCOINKERNEL_API btck_BlockValidationState* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_validation_state_create();


BITCOINKERNEL_API btck_ValidationMode btck_block_validation_state_get_validation_mode(

    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(

    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockValidationState* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_validation_state_copy(

    const btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_block_validation_state_destroy(

    btck_BlockValidationState* block_validation_state) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_height(

    const btck_Chain* chain) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_get_by_height(

    const btck_Chain* chain,

    int block_height) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_chain_contains(

    const btck_Chain* chain,

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_read(

    const btck_ChainstateManager* chainstate_manager,

    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API btck_BlockSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_copy(

    const btck_BlockSpentOutputs* block_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_count(

    const btck_BlockSpentOutputs* block_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_TransactionSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_spent_outputs_get_transaction_spent_outputs_at(

    const btck_BlockSpentOutputs* block_spent_outputs,

    size_t transaction_spent_outputs_index) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs* block_spent_outputs);


BITCOINKERNEL_API btck_TransactionSpentOutputs* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_copy(

    const btck_TransactionSpentOutputs* transaction_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API size_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_count(

    const btck_TransactionSpentOutputs* transaction_spent_outputs) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_Coin* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_spent_outputs_get_coin_at(

    const btck_TransactionSpentOutputs* transaction_spent_outputs,

    size_t coin_index) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs* transaction_spent_outputs);


BITCOINKERNEL_API btck_TransactionInput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_input_copy(

    const btck_TransactionInput* transaction_input) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_TransactionOutPoint* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_input_get_out_point(

    const btck_TransactionInput* transaction_input) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_transaction_input_destroy(btck_TransactionInput* transaction_input);


BITCOINKERNEL_API btck_TransactionOutPoint* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_out_point_copy(

    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_out_point_get_index(

    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transaction_out_point_get_txid(

    const btck_TransactionOutPoint* transaction_out_point) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_transaction_out_point_destroy(btck_TransactionOutPoint* transaction_out_point);


BITCOINKERNEL_API btck_Txid* BITCOINKERNEL_WARN_UNUSED_RESULT btck_txid_copy(

    const btck_Txid* txid) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_txid_equals(

    const btck_Txid* txid1, const btck_Txid* txid2) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_txid_to_bytes(

    const btck_Txid* txid, unsigned char output[32]) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_txid_destroy(btck_Txid* txid);


BITCOINKERNEL_API btck_Coin* BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_copy(

    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_confirmation_height(

    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_is_coinbase(

    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT btck_coin_get_output(

    const btck_Coin* coin) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_coin_destroy(btck_Coin* coin);


BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_create(

    const unsigned char block_hash[32]) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_equals(

    const btck_BlockHash* hash1, const btck_BlockHash* hash2) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_copy(

    const btck_BlockHash* block_hash) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_block_hash_to_bytes(

    const btck_BlockHash* block_hash, unsigned char output[32]) BITCOINKERNEL_ARG_NONNULL(1, 2);


BITCOINKERNEL_API void btck_block_hash_destroy(btck_BlockHash* block_hash);


BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_create(

    const void* raw_block_header, size_t raw_block_header_len);


BITCOINKERNEL_API btck_BlockHeader* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_copy(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_hash(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API const btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_prev_hash(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_timestamp(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_bits(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API int32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_version(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API uint32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_header_get_nonce(

    const btck_BlockHeader* header) BITCOINKERNEL_ARG_NONNULL(1);


BITCOINKERNEL_API void btck_block_header_destroy(btck_BlockHeader* header);


#ifdef __cplusplus

} // extern "C"

#endif // __cplusplus


#endif // BITCOIN_KERNEL_BITCOINKERNEL_H

BITCOINKERNEL_API
#define BITCOINKERNEL_API
Definition bitcoinkernel.h:27

btck_block_hash_equals
BITCOINKERNEL_API int btck_block_hash_equals(const btck_BlockHash *hash1, const btck_BlockHash *hash2) 2)
Check if two block hashes are equal.

btck_chainstate_manager_import_blocks
BITCOINKERNEL_API int BITCOINKERNEL_API int btck_chainstate_manager_import_blocks(btck_ChainstateManager *chainstate_manager, 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....

btck_block_spent_outputs_copy
BITCOINKERNEL_API btck_BlockSpentOutputs * btck_block_spent_outputs_copy(const btck_BlockSpentOutputs *block_spent_outputs)
Copy a block's spent outputs.

btck_transaction_output_create
BITCOINKERNEL_API 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_LogLevel
uint8_t btck_LogLevel
Definition bitcoinkernel.h:442

btck_coin_confirmation_height
BITCOINKERNEL_API uint32_t btck_coin_confirmation_height(const btck_Coin *coin)
Returns the block height where the transaction that created this coin was included in.

btck_block_get_transaction_at
BITCOINKERNEL_API const btck_Transaction * btck_block_get_transaction_at(const btck_Block *block, size_t transaction_index)
Get the transaction at the provided index. The returned transaction is not owned and depends on the l...

btck_chain_parameters_create
BITCOINKERNEL_API btck_ChainParameters * btck_chain_parameters_create(btck_ChainType chain_type)
Creates a chain parameters struct with default parameters based on the passed in chain type.

btck_transaction_out_point_copy
BITCOINKERNEL_API btck_TransactionOutPoint * btck_transaction_out_point_copy(const btck_TransactionOutPoint *transaction_out_point)
Copy a transaction out point.

btck_ContextOptions
struct btck_ContextOptions btck_ContextOptions
Definition bitcoinkernel.h:164

btck_transaction_to_bytes
BITCOINKERNEL_API int btck_transaction_to_bytes(const btck_Transaction *transaction, btck_WriteBytes writer, void *user_data) 2)
Serializes the transaction through the passed in callback to bytes. This is consensus serialization t...

btck_block_hash_to_bytes
BITCOINKERNEL_API void btck_block_hash_to_bytes(const btck_BlockHash *block_hash, unsigned char output[32]) 2)
Serializes the block hash to bytes.

btck_block_header_get_bits
BITCOINKERNEL_API uint32_t btck_block_header_get_bits(const btck_BlockHeader *header)
Get the nBits difficulty target from btck_BlockHeader.

btck_logging_connection_destroy
BITCOINKERNEL_API void btck_logging_connection_destroy(btck_LoggingConnection *logging_connection)

btck_Context
struct btck_Context btck_Context
Definition bitcoinkernel.h:180

btck_transaction_spent_outputs_count
BITCOINKERNEL_API 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.

btck_block_spent_outputs_read
BITCOINKERNEL_API btck_BlockSpentOutputs * btck_block_spent_outputs_read(const btck_ChainstateManager *chainstate_manager, const btck_BlockTreeEntry *block_tree_entry) 2)
Reads the block spent coins data the passed in block tree entry points to from disk and returns it.

btck_block_tree_entry_get_block_header
BITCOINKERNEL_API btck_BlockHeader * btck_block_tree_entry_get_block_header(const btck_BlockTreeEntry *block_tree_entry)
Return the btck_BlockHeader associated with this entry.

btck_WriteBytes
int(* btck_WriteBytes)(const void *bytes, size_t size, void *userdata)
Definition bitcoinkernel.h:353

btck_BlockHash
struct btck_BlockHash btck_BlockHash
Definition bitcoinkernel.h:269

BITCOINKERNEL_WARN_UNUSED_RESULT
#define BITCOINKERNEL_WARN_UNUSED_RESULT
Definition bitcoinkernel.h:36

btck_chainstate_manager_destroy
BITCOINKERNEL_API void btck_chainstate_manager_destroy(btck_ChainstateManager *chainstate_manager)

btck_block_count_transactions
BITCOINKERNEL_API size_t btck_block_count_transactions(const btck_Block *block)
Count the number of transactions contained in a block.

btck_coin_copy
BITCOINKERNEL_API btck_Coin * btck_coin_copy(const btck_Coin *coin)
Copy a coin.

btck_chainstate_manager_process_block_header
BITCOINKERNEL_API int btck_chainstate_manager_process_block_header(btck_ChainstateManager *chainstate_manager, const btck_BlockHeader *header, btck_BlockValidationState *block_validation_state) 2
Processes and validates the provided btck_BlockHeader.

btck_transaction_destroy
BITCOINKERNEL_API void btck_transaction_destroy(btck_Transaction *transaction)

btck_block_copy
BITCOINKERNEL_API btck_Block * btck_block_copy(const btck_Block *block)
Copy a block. Blocks are reference counted, so this just increments the reference count.

btck_block_validation_state_copy
BITCOINKERNEL_API btck_BlockValidationState * btck_block_validation_state_copy(const btck_BlockValidationState *block_validation_state)
Copies the btck_BlockValidationState.

btck_block_header_get_prev_hash
BITCOINKERNEL_API const btck_BlockHash * btck_block_header_get_prev_hash(const btck_BlockHeader *header)
Get the previous btck_BlockHash from btck_BlockHeader. The returned hash is unowned and only valid fo...

btck_chainstate_manager_get_best_entry
BITCOINKERNEL_API 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_script_pubkey_copy
BITCOINKERNEL_API btck_ScriptPubkey * btck_script_pubkey_copy(const btck_ScriptPubkey *script_pubkey)
Copy a script pubkey.

btck_ChainType
uint8_t btck_ChainType
Definition bitcoinkernel.h:488

btck_logging_connection_create
BITCOINKERNEL_API btck_LoggingConnection * btck_logging_connection_create(btck_LogCallback log_callback, void *user_data, btck_DestroyCallback user_data_destroy_callback)
Start logging messages through the provided callback. Log messages produced before this function is f...

btck_chainstate_manager_options_set_worker_threads_num
BITCOINKERNEL_API void btck_chainstate_manager_options_set_worker_threads_num(btck_ChainstateManagerOptions *chainstate_manager_options, int worker_threads)
Set the number of available worker threads used during validation.

btck_block_to_bytes
BITCOINKERNEL_API int btck_block_to_bytes(const btck_Block *block, btck_WriteBytes writer, void *user_data) 2)
Serializes the block through the passed in callback to bytes. This is consensus serialization that is...

btck_context_copy
BITCOINKERNEL_API btck_Context * btck_context_copy(const btck_Context *context)

btck_LogCallback
void(* btck_LogCallback)(void *user_data, const char *message, size_t message_len)
Definition bitcoinkernel.h:324

btck_ValidationInterfaceBlockChecked
void(* btck_ValidationInterfaceBlockChecked)(void *user_data, btck_Block *block, const btck_BlockValidationState *state)
Definition bitcoinkernel.h:345

btck_LoggingConnection
struct btck_LoggingConnection btck_LoggingConnection
Definition bitcoinkernel.h:143

btck_BlockValidationResult
uint32_t btck_BlockValidationResult
Definition bitcoinkernel.h:367

btck_block_validation_state_get_validation_mode
BITCOINKERNEL_API btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState *block_validation_state)

btck_chain_get_height
BITCOINKERNEL_API int32_t btck_chain_get_height(const btck_Chain *chain)
Return the height of the tip of the chain.

btck_ValidationMode
uint8_t btck_ValidationMode
Definition bitcoinkernel.h:359

btck_txid_equals
BITCOINKERNEL_API int btck_txid_equals(const btck_Txid *txid1, const btck_Txid *txid2) 2)
Check if two txids are equal.

btck_logging_disable_category
BITCOINKERNEL_API void btck_logging_disable_category(btck_LogCategory category)
Disable a specific log category for the global internal logger. This changes a global setting and wil...

btck_ValidationInterfacePoWValidBlock
void(* btck_ValidationInterfacePoWValidBlock)(void *user_data, btck_Block *block, const btck_BlockTreeEntry *entry)
Definition bitcoinkernel.h:346

btck_block_validation_state_create
BITCOINKERNEL_API btck_BlockValidationState * btck_block_validation_state_create()

btck_block_get_hash
BITCOINKERNEL_API btck_BlockHash * btck_block_get_hash(const btck_Block *block)
Calculate and return the hash of a block.

btck_transaction_get_txid
BITCOINKERNEL_API const btck_Txid * btck_transaction_get_txid(const btck_Transaction *transaction)
Get the txid of a transaction. The returned txid is not owned and depends on the lifetime of the tran...

btck_SynchronizationState
uint8_t btck_SynchronizationState
Definition bitcoinkernel.h:308

btck_context_options_destroy
BITCOINKERNEL_API void btck_context_options_destroy(btck_ContextOptions *context_options)

btck_NotifyProgress
void(* btck_NotifyProgress)(void *user_data, const char *title, size_t title_len, int progress_percent, int resume_possible)
Definition bitcoinkernel.h:336

btck_transaction_spent_outputs_copy
BITCOINKERNEL_API btck_TransactionSpentOutputs * btck_transaction_spent_outputs_copy(const btck_TransactionSpentOutputs *transaction_spent_outputs)
Copy a transaction's spent outputs.

btck_BlockTreeEntry
struct btck_BlockTreeEntry btck_BlockTreeEntry
Definition bitcoinkernel.h:193

btck_NotifyWarningUnset
void(* btck_NotifyWarningUnset)(void *user_data, btck_Warning warning)
Definition bitcoinkernel.h:338

btck_chainstate_manager_options_create
BITCOINKERNEL_API btck_ChainstateManagerOptions * btck_chainstate_manager_options_create(const btck_Context *context, const char *data_directory, size_t data_directory_len, const char *blocks_directory, size_t blocks_directory_len)
Create options for the chainstate manager.

btck_block_header_copy
BITCOINKERNEL_API btck_BlockHeader * btck_block_header_copy(const btck_BlockHeader *header)
Copy a btck_BlockHeader.

btck_ValidationInterfaceBlockDisconnected
void(* btck_ValidationInterfaceBlockDisconnected)(void *user_data, btck_Block *block, const btck_BlockTreeEntry *entry)
Definition bitcoinkernel.h:348

btck_transaction_input_copy
BITCOINKERNEL_API btck_TransactionInput * btck_transaction_input_copy(const btck_TransactionInput *transaction_input)
Copy a transaction input.

btck_chainstate_manager_options_destroy
BITCOINKERNEL_API void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions *chainstate_manager_options)

btck_block_spent_outputs_get_transaction_spent_outputs_at
BITCOINKERNEL_API const btck_TransactionSpentOutputs * btck_block_spent_outputs_get_transaction_spent_outputs_at(const btck_BlockSpentOutputs *block_spent_outputs, size_t transaction_spent_outputs_index)
Returns a transaction spent outputs contained in the block spent outputs at a certain index....

btck_transaction_out_point_get_txid
BITCOINKERNEL_API const btck_Txid * btck_transaction_out_point_get_txid(const btck_TransactionOutPoint *transaction_out_point)
Get the txid from the transaction out point. The returned txid is not owned and depends on the lifeti...

btck_TransactionSpentOutputs
struct btck_TransactionSpentOutputs btck_TransactionSpentOutputs
Definition bitcoinkernel.h:254

btck_BlockSpentOutputs
struct btck_BlockSpentOutputs btck_BlockSpentOutputs
Definition bitcoinkernel.h:245

btck_block_validation_state_get_block_validation_result
BITCOINKERNEL_API btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState *block_validation_state)

btck_Chain
struct btck_Chain btck_Chain
Definition bitcoinkernel.h:232

BITCOINKERNEL_ARG_NONNULL
#define BITCOINKERNEL_ARG_NONNULL(...)
Definition bitcoinkernel.h:52

btck_DestroyCallback
void(* btck_DestroyCallback)(void *user_data)
Definition bitcoinkernel.h:329

btck_precomputed_transaction_data_destroy
BITCOINKERNEL_API void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData *precomputed_txdata)

btck_chainstate_manager_options_update_chainstate_db_in_memory
BITCOINKERNEL_API void btck_chainstate_manager_options_update_chainstate_db_in_memory(btck_ChainstateManagerOptions *chainstate_manager_options, int chainstate_db_in_memory)
Sets chainstate db in memory in the options.

btck_context_interrupt
BITCOINKERNEL_API int btck_context_interrupt(btck_Context *context)
Interrupt can be used to halt long-running validation functions like when reindexing,...

btck_transaction_output_get_script_pubkey
BITCOINKERNEL_API const btck_ScriptPubkey * btck_transaction_output_get_script_pubkey(const btck_TransactionOutput *transaction_output)
Get the script pubkey of the output. The returned script pubkey is not owned and depends on the lifet...

btck_ScriptVerificationFlags
uint32_t btck_ScriptVerificationFlags
Definition bitcoinkernel.h:471

btck_block_hash_destroy
BITCOINKERNEL_API void btck_block_hash_destroy(btck_BlockHash *block_hash)

btck_block_tree_entry_equals
BITCOINKERNEL_API int btck_block_tree_entry_equals(const btck_BlockTreeEntry *entry1, const btck_BlockTreeEntry *entry2) 2)
Check if two block tree entries are equal. Two block tree entries are equal when they point to the sa...

btck_chain_get_by_height
BITCOINKERNEL_API const btck_BlockTreeEntry * btck_chain_get_by_height(const btck_Chain *chain, int block_height)
Retrieve a block tree entry by its height in the currently active chain. Once retrieved there is no g...

btck_block_hash_copy
BITCOINKERNEL_API btck_BlockHash * btck_block_hash_copy(const btck_BlockHash *block_hash)
Copy a block hash.

btck_transaction_output_get_amount
BITCOINKERNEL_API int64_t btck_transaction_output_get_amount(const btck_TransactionOutput *transaction_output)
Get the amount in the output.

btck_transaction_get_output_at
BITCOINKERNEL_API const btck_TransactionOutput * btck_transaction_get_output_at(const btck_Transaction *transaction, size_t output_index)
Get the transaction outputs at the provided index. The returned transaction output is not owned and d...

btck_ScriptPubkey
struct btck_ScriptPubkey btck_ScriptPubkey
Definition bitcoinkernel.h:125

btck_block_header_get_version
BITCOINKERNEL_API int32_t btck_block_header_get_version(const btck_BlockHeader *header)
Get the version from btck_BlockHeader.

btck_block_spent_outputs_count
BITCOINKERNEL_API 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_Coin
struct btck_Coin btck_Coin
Definition bitcoinkernel.h:262

btck_transaction_get_input_at
BITCOINKERNEL_API const btck_TransactionInput * btck_transaction_get_input_at(const btck_Transaction *transaction, size_t input_index)
Get the transaction input at the provided index. The returned transaction input is not owned and depe...

btck_chain_contains
BITCOINKERNEL_API int btck_chain_contains(const btck_Chain *chain, const btck_BlockTreeEntry *block_tree_entry) 2)
Return true if the passed in chain contains the block tree entry.

btck_block_header_destroy
BITCOINKERNEL_API void btck_block_header_destroy(btck_BlockHeader *header)

btck_block_create
BITCOINKERNEL_API btck_Block * btck_block_create(const void *raw_block, size_t raw_block_len)
Parse a serialized raw block into a new block object.

btck_coin_get_output
BITCOINKERNEL_API const btck_TransactionOutput * btck_coin_get_output(const btck_Coin *coin)
Return the transaction output of a coin. The returned pointer is unowned and only valid for the lifet...

btck_TransactionInput
struct btck_TransactionInput btck_TransactionInput
Definition bitcoinkernel.h:276

btck_block_validation_state_destroy
BITCOINKERNEL_API void btck_block_validation_state_destroy(btck_BlockValidationState *block_validation_state)

btck_context_create
BITCOINKERNEL_API btck_Context * btck_context_create(const btck_ContextOptions *context_options)
Create a new kernel context. If the options have not been previously set, their corresponding fields ...

btck_TransactionOutPoint
struct btck_TransactionOutPoint btck_TransactionOutPoint
Definition bitcoinkernel.h:283

btck_transaction_create
BITCOINKERNEL_API btck_Transaction * btck_transaction_create(const void *raw_transaction, size_t raw_transaction_len)
Create a new transaction from the serialized data.

btck_script_pubkey_destroy
BITCOINKERNEL_API void btck_script_pubkey_destroy(btck_ScriptPubkey *script_pubkey)

btck_transaction_output_destroy
BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput *transaction_output)

btck_transaction_copy
BITCOINKERNEL_API btck_Transaction * btck_transaction_copy(const btck_Transaction *transaction)
Copy a transaction. Transactions are reference counted, so this just increments the reference count.

btck_transaction_output_copy
BITCOINKERNEL_API btck_TransactionOutput * btck_transaction_output_copy(const btck_TransactionOutput *transaction_output)
Copy a transaction output.

btck_block_tree_entry_get_block_hash
BITCOINKERNEL_API const btck_BlockHash * btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry *block_tree_entry)
Return the block hash associated with a block tree entry.

btck_block_get_header
BITCOINKERNEL_API btck_BlockHeader * btck_block_get_header(const btck_Block *block)
Get the btck_BlockHeader from the block.

btck_script_pubkey_create
BITCOINKERNEL_API btck_ScriptPubkey * btck_script_pubkey_create(const void *script_pubkey, size_t script_pubkey_len)
Create a script pubkey from serialized data.

btck_txid_destroy
BITCOINKERNEL_API void btck_txid_destroy(btck_Txid *txid)

btck_ScriptVerifyStatus
uint8_t btck_ScriptVerifyStatus
Definition bitcoinkernel.h:463

btck_script_pubkey_to_bytes
BITCOINKERNEL_API int btck_script_pubkey_to_bytes(const btck_ScriptPubkey *script_pubkey, btck_WriteBytes writer, void *user_data) 2)
Serializes the script pubkey through the passed in callback to bytes.

btck_transaction_spent_outputs_get_coin_at
BITCOINKERNEL_API 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. The returned pointer is...

btck_block_tree_entry_get_height
BITCOINKERNEL_API int32_t btck_block_tree_entry_get_height(const btck_BlockTreeEntry *block_tree_entry)
Return the height of a certain block tree entry.

btck_txid_copy
BITCOINKERNEL_API btck_Txid * btck_txid_copy(const btck_Txid *txid)
Copy a txid.

btck_transaction_out_point_destroy
BITCOINKERNEL_API void btck_transaction_out_point_destroy(btck_TransactionOutPoint *transaction_out_point)

btck_block_read
BITCOINKERNEL_API btck_Block * btck_block_read(const btck_ChainstateManager *chainstate_manager, const btck_BlockTreeEntry *block_tree_entry) 2)
Reads the block the passed in block tree entry points to from disk and returns it.

btck_block_hash_create
BITCOINKERNEL_API btck_BlockHash * btck_block_hash_create(const unsigned char block_hash[32])
Create a block hash from its raw data.

btck_NotifyBlockTip
void(* btck_NotifyBlockTip)(void *user_data, btck_SynchronizationState state, const btck_BlockTreeEntry *entry, double verification_progress)
Definition bitcoinkernel.h:334

btck_LogCategory
uint8_t btck_LogCategory
Definition bitcoinkernel.h:426

btck_context_options_set_validation_interface
BITCOINKERNEL_API void btck_context_options_set_validation_interface(btck_ContextOptions *context_options, btck_ValidationInterfaceCallbacks validation_interface_callbacks)
Set the validation interface callbacks for the context options. The context created with the options ...

btck_ValidationInterfaceBlockConnected
void(* btck_ValidationInterfaceBlockConnected)(void *user_data, btck_Block *block, const btck_BlockTreeEntry *entry)
Definition bitcoinkernel.h:347

btck_transaction_spent_outputs_destroy
BITCOINKERNEL_API void btck_transaction_spent_outputs_destroy(btck_TransactionSpentOutputs *transaction_spent_outputs)

btck_logging_set_options
BITCOINKERNEL_API void btck_logging_set_options(btck_LoggingOptions options)
Set some options for the global internal logger. This changes global settings and will override setti...

btck_chain_parameters_copy
BITCOINKERNEL_API btck_ChainParameters * btck_chain_parameters_copy(const btck_ChainParameters *chain_parameters)

btck_ChainstateManager
struct btck_ChainstateManager btck_ChainstateManager
Definition bitcoinkernel.h:213

btck_chain_parameters_destroy
BITCOINKERNEL_API void btck_chain_parameters_destroy(btck_ChainParameters *chain_parameters)

btck_TransactionOutput
struct btck_TransactionOutput btck_TransactionOutput
Definition bitcoinkernel.h:130

btck_transaction_out_point_get_index
BITCOINKERNEL_API uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint *transaction_out_point)
Get the output position from the transaction out point.

btck_chainstate_manager_process_block
BITCOINKERNEL_API int btck_chainstate_manager_process_block(btck_ChainstateManager *chainstate_manager, const btck_Block *block, int *new_block) 2
Process and validate the passed in block with the chainstate manager. Processing first does checks on...

btck_chainstate_manager_create
BITCOINKERNEL_API btck_ChainstateManager * btck_chainstate_manager_create(const btck_ChainstateManagerOptions *chainstate_manager_options)
Create a chainstate manager. This is the main object for many validation tasks as well as for retriev...

btck_PrecomputedTransactionData
struct btck_PrecomputedTransactionData btck_PrecomputedTransactionData
Definition bitcoinkernel.h:293

btck_logging_enable_category
BITCOINKERNEL_API void btck_logging_enable_category(btck_LogCategory category)
Enable a specific log category for the global internal logger. This changes a global setting and will...

btck_BlockValidationState
struct btck_BlockValidationState btck_BlockValidationState
Definition bitcoinkernel.h:226

btck_transaction_input_get_out_point
BITCOINKERNEL_API const btck_TransactionOutPoint * btck_transaction_input_get_out_point(const btck_TransactionInput *transaction_input)
Get the transaction out point. The returned transaction out point is not owned and depends on the lif...

btck_block_tree_entry_get_previous
BITCOINKERNEL_API const btck_BlockTreeEntry * btck_block_tree_entry_get_previous(const btck_BlockTreeEntry *block_tree_entry)
Returns the previous block tree entry in the tree, or null if the current block tree entry is the gen...

btck_block_destroy
BITCOINKERNEL_API void btck_block_destroy(btck_Block *block)

btck_Warning
uint8_t btck_Warning
Definition bitcoinkernel.h:314

btck_ChainstateManagerOptions
struct btck_ChainstateManagerOptions btck_ChainstateManagerOptions
Definition bitcoinkernel.h:202

btck_coin_destroy
BITCOINKERNEL_API void btck_coin_destroy(btck_Coin *coin)

btck_NotifyHeaderTip
void(* btck_NotifyHeaderTip)(void *user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync)
Definition bitcoinkernel.h:335

btck_chainstate_manager_options_update_block_tree_db_in_memory
BITCOINKERNEL_API void btck_chainstate_manager_options_update_block_tree_db_in_memory(btck_ChainstateManagerOptions *chainstate_manager_options, int block_tree_db_in_memory)
Sets block tree db in memory in the options.

btck_precomputed_transaction_data_copy
BITCOINKERNEL_API btck_PrecomputedTransactionData * btck_precomputed_transaction_data_copy(const btck_PrecomputedTransactionData *precomputed_txdata)
Copy precomputed transaction data.

btck_precomputed_transaction_data_create
BITCOINKERNEL_API 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.

btck_script_pubkey_verify
BITCOINKERNEL_API int btck_script_pubkey_verify(const btck_ScriptPubkey *script_pubkey, int64_t amount, const btck_Transaction *tx_to, const btck_PrecomputedTransactionData *precomputed_txdata, unsigned int input_index, btck_ScriptVerificationFlags flags, btck_ScriptVerifyStatus *status) 3)
Verify if the input at input_index of tx_to spends the script pubkey under the constraints specified ...

btck_block_header_create
BITCOINKERNEL_API btck_BlockHeader * btck_block_header_create(const void *raw_block_header, size_t raw_block_header_len)
Create a btck_BlockHeader from serialized data.

btck_context_options_set_chainparams
BITCOINKERNEL_API void btck_context_options_set_chainparams(btck_ContextOptions *context_options, const btck_ChainParameters *chain_parameters) 2)
Sets the chain params for the context options. The context created with the options will be configure...

btck_block_spent_outputs_destroy
BITCOINKERNEL_API void btck_block_spent_outputs_destroy(btck_BlockSpentOutputs *block_spent_outputs)

btck_chainstate_manager_get_active_chain
BITCOINKERNEL_API int BITCOINKERNEL_API const btck_Chain * btck_chainstate_manager_get_active_chain(const btck_ChainstateManager *chainstate_manager)
Returns the best known currently active chain. Its lifetime is dependent on the chainstate manager....

btck_chainstate_manager_options_set_wipe_dbs
BITCOINKERNEL_API int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions *chainstate_manager_options, int wipe_block_tree_db, int wipe_chainstate_db)
Sets wipe db in the options. In combination with calling btck_chainstate_manager_import_blocks this t...

btck_ChainParameters
struct btck_ChainParameters btck_ChainParameters
Definition bitcoinkernel.h:152

btck_Block
struct btck_Block btck_Block
Definition bitcoinkernel.h:218

btck_logging_set_level_category
BITCOINKERNEL_API void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
Set the log level of the global internal logger. This does not enable the selected categories....

btck_transaction_count_inputs
BITCOINKERNEL_API size_t btck_transaction_count_inputs(const btck_Transaction *transaction)
Get the number of inputs of a transaction.

btck_coin_is_coinbase
BITCOINKERNEL_API int btck_coin_is_coinbase(const btck_Coin *coin)
Returns whether the containing transaction was a coinbase.

btck_chainstate_manager_get_block_tree_entry_by_hash
BITCOINKERNEL_API const btck_BlockTreeEntry * btck_chainstate_manager_get_block_tree_entry_by_hash(const btck_ChainstateManager *chainstate_manager, const btck_BlockHash *block_hash) 2)
Retrieve a block tree entry by its block hash.

btck_logging_disable
BITCOINKERNEL_API void btck_logging_disable()
This disables the global internal logger. No log messages will be buffered internally anymore once th...

btck_NotifyWarningSet
void(* btck_NotifyWarningSet)(void *user_data, btck_Warning warning, const char *message, size_t message_len)
Definition bitcoinkernel.h:337

btck_transaction_input_destroy
BITCOINKERNEL_API void btck_transaction_input_destroy(btck_TransactionInput *transaction_input)

btck_context_options_set_notifications
BITCOINKERNEL_API void btck_context_options_set_notifications(btck_ContextOptions *context_options, btck_NotificationInterfaceCallbacks notifications)
Set the kernel notifications for the context options. The context created with the options will be co...

btck_context_destroy
BITCOINKERNEL_API void btck_context_destroy(btck_Context *context)

btck_context_options_create
BITCOINKERNEL_API btck_ContextOptions * btck_context_options_create()

btck_block_header_get_nonce
BITCOINKERNEL_API uint32_t btck_block_header_get_nonce(const btck_BlockHeader *header)
Get the nonce from btck_BlockHeader.

btck_block_header_get_hash
BITCOINKERNEL_API btck_BlockHash * btck_block_header_get_hash(const btck_BlockHeader *header)
Get the btck_BlockHash.

btck_block_header_get_timestamp
BITCOINKERNEL_API uint32_t btck_block_header_get_timestamp(const btck_BlockHeader *header)
Get the timestamp from btck_BlockHeader.

btck_NotifyFatalError
void(* btck_NotifyFatalError)(void *user_data, const char *message, size_t message_len)
Definition bitcoinkernel.h:340

btck_NotifyFlushError
void(* btck_NotifyFlushError)(void *user_data, const char *message, size_t message_len)
Definition bitcoinkernel.h:339

btck_BlockHeader
struct btck_BlockHeader btck_BlockHeader
Definition bitcoinkernel.h:305

btck_Txid
struct btck_Txid btck_Txid
Definition bitcoinkernel.h:300

btck_transaction_count_outputs
BITCOINKERNEL_API size_t btck_transaction_count_outputs(const btck_Transaction *transaction)
Get the number of outputs of a transaction.

btck_txid_to_bytes
BITCOINKERNEL_API void btck_txid_to_bytes(const btck_Txid *txid, unsigned char output[32]) 2)
Serializes the txid to bytes.

btck_Transaction
struct btck_Transaction btck_Transaction
Definition bitcoinkernel.h:120

btck_LoggingOptions
Definition bitcoinkernel.h:452

btck_LoggingOptions::always_print_category_levels
int always_print_category_levels
Prepend the log category and level to log messages.
Definition bitcoinkernel.h:457

btck_LoggingOptions::log_time_micros
int log_time_micros
Log timestamps in microsecond precision.
Definition bitcoinkernel.h:454

btck_LoggingOptions::log_threadnames
int log_threadnames
Prepend the name of the thread to log messages.
Definition bitcoinkernel.h:455

btck_LoggingOptions::log_sourcelocations
int log_sourcelocations
Prepend the source location to log messages.
Definition bitcoinkernel.h:456

btck_LoggingOptions::log_timestamps
int log_timestamps
Prepend a timestamp to log messages.
Definition bitcoinkernel.h:453

btck_NotificationInterfaceCallbacks
Definition bitcoinkernel.h:409

btck_NotificationInterfaceCallbacks::warning_unset
btck_NotifyWarningUnset warning_unset
A previous condition leading to the issuance of a warning is no longer given.
Definition bitcoinkernel.h:418

btck_NotificationInterfaceCallbacks::block_tip
btck_NotifyBlockTip block_tip
The chain's tip was updated to the provided block entry.
Definition bitcoinkernel.h:414

btck_NotificationInterfaceCallbacks::warning_set
btck_NotifyWarningSet warning_set
A warning issued by the kernel library during validation.
Definition bitcoinkernel.h:417

btck_NotificationInterfaceCallbacks::flush_error
btck_NotifyFlushError flush_error
An error encountered when flushing data to disk.
Definition bitcoinkernel.h:419

btck_NotificationInterfaceCallbacks::progress
btck_NotifyProgress progress
Reports on current block synchronization progress.
Definition bitcoinkernel.h:416

btck_NotificationInterfaceCallbacks::fatal_error
btck_NotifyFatalError fatal_error
An unrecoverable system error encountered by the library.
Definition bitcoinkernel.h:420

btck_NotificationInterfaceCallbacks::user_data_destroy
btck_DestroyCallback user_data_destroy
Frees the provided user data structure.
Definition bitcoinkernel.h:413

btck_NotificationInterfaceCallbacks::user_data
void * user_data
Definition bitcoinkernel.h:410

btck_NotificationInterfaceCallbacks::header_tip
btck_NotifyHeaderTip header_tip
A new best block header was added.
Definition bitcoinkernel.h:415

btck_ValidationInterfaceCallbacks
Definition bitcoinkernel.h:384

btck_ValidationInterfaceCallbacks::user_data_destroy
btck_DestroyCallback user_data_destroy
Frees the provided user data structure.
Definition bitcoinkernel.h:388

btck_ValidationInterfaceCallbacks::block_connected
btck_ValidationInterfaceBlockConnected block_connected
Called when a block is valid and has now been connected to the best chain.
Definition bitcoinkernel.h:393

btck_ValidationInterfaceCallbacks::block_checked
btck_ValidationInterfaceBlockChecked block_checked
Definition bitcoinkernel.h:389

btck_ValidationInterfaceCallbacks::block_disconnected
btck_ValidationInterfaceBlockDisconnected block_disconnected
Called during a re-org when a block has been removed from the best chain.
Definition bitcoinkernel.h:394

btck_ValidationInterfaceCallbacks::user_data
void * user_data
Definition bitcoinkernel.h:385

btck_ValidationInterfaceCallbacks::pow_valid_block
btck_ValidationInterfacePoWValidBlock pow_valid_block
Definition bitcoinkernel.h:391