#define BITCOINKERNEL_BUILD

#include <kernel/bitcoinkernel.h>

#include <chain.h>

#include <coins.h>

#include <consensus/validation.h>

#include <dbwrapper.h>

#include <kernel/caches.h>

#include <kernel/chainparams.h>

#include <kernel/checks.h>

#include <kernel/context.h>

#include <kernel/notifications_interface.h>

#include <kernel/warning.h>

#include <logging.h>

#include <node/blockstorage.h>

#include <node/chainstate.h>

#include <primitives/block.h>

#include <primitives/transaction.h>

#include <script/interpreter.h>

#include <script/script.h>

#include <serialize.h>

#include <streams.h>

#include <sync.h>

#include <uint256.h>

#include <undo.h>

#include <util/check.h>

#include <util/fs.h>

#include <util/result.h>

#include <util/signalinterrupt.h>

#include <util/task_runner.h>

#include <util/translation.h>

#include <validation.h>

#include <validationinterface.h>

#include <cstddef>

#include <cstring>

#include <exception>

#include <functional>

#include <list>

#include <memory>

#include <span>

#include <stdexcept>

#include <string>

#include <tuple>

#include <utility>

#include <vector>

using kernel::ChainstateRole;

using util::ImmediateTaskRunner;

extern const TranslateFn G_TRANSLATION_FUN{nullptr};

static const kernel::Context btck_context_static{};

namespace {

bool is_valid_flag_combination(script_verify_flags flags)

}

class WriterStream

};

template <typename C, typename CPP>

struct Handle {

};

} // namespace

struct btck_BlockTreeEntry: Handle<btck_BlockTreeEntry, CBlockIndex> {};

struct btck_Block : Handle<btck_Block, std::shared_ptr<const CBlock>> {};

struct btck_BlockValidationState : Handle<btck_BlockValidationState, BlockValidationState> {};

namespace {

BCLog::Level get_bclog_level(btck_LogLevel level)

}

BCLog::LogFlags get_bclog_flag(btck_LogCategory category)

}

btck_SynchronizationState cast_state(SynchronizationState state)

}

btck_Warning cast_btck_warning(kernel::Warning warning)

}

struct LoggingConnection {

};

class KernelNotifications final : public kernel::Notifications

};

class KernelValidationInterface final : public CValidationInterface

};

struct ContextOptions {

};

class Context

};

struct ChainstateManagerOptions {

};

struct ChainMan {

};

} // namespace

struct btck_Transaction : Handle<btck_Transaction, std::shared_ptr<const CTransaction>> {};

struct btck_TransactionOutput : Handle<btck_TransactionOutput, CTxOut> {};

struct btck_ScriptPubkey : Handle<btck_ScriptPubkey, CScript> {};

struct btck_LoggingConnection : Handle<btck_LoggingConnection, LoggingConnection> {};

struct btck_ContextOptions : Handle<btck_ContextOptions, ContextOptions> {};

struct btck_Context : Handle<btck_Context, std::shared_ptr<const Context>> {};

struct btck_ChainParameters : Handle<btck_ChainParameters, CChainParams> {};

struct btck_ChainstateManagerOptions : Handle<btck_ChainstateManagerOptions, ChainstateManagerOptions> {};

struct btck_ChainstateManager : Handle<btck_ChainstateManager, ChainMan> {};

struct btck_Chain : Handle<btck_Chain, CChain> {};

struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<CBlockUndo>> {};

struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};

struct btck_Coin : Handle<btck_Coin, Coin> {};

struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};

struct btck_TransactionInput : Handle<btck_TransactionInput, CTxIn> {};

struct btck_TransactionOutPoint: Handle<btck_TransactionOutPoint, COutPoint> {};

struct btck_Txid: Handle<btck_Txid, Txid> {};

struct btck_PrecomputedTransactionData : Handle<btck_PrecomputedTransactionData, PrecomputedTransactionData> {};

struct btck_BlockHeader: Handle<btck_BlockHeader, CBlockHeader> {};

btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)

{

if (raw_transaction == nullptr && raw_transaction_len != 0) {

return nullptr;

}

try {

SpanReader stream{std::span{reinterpret_cast<const std::byte*>(raw_transaction), raw_transaction_len}};

return btck_Transaction::create(std::make_shared<const CTransaction>(deserialize, TX_WITH_WITNESS, stream));

} catch (...) {

return nullptr;

}

}

size_t btck_transaction_count_outputs(const btck_Transaction* transaction)

{

return btck_Transaction::get(transaction)->vout.size();

}

const btck_TransactionOutput* btck_transaction_get_output_at(const btck_Transaction* transaction, size_t output_index)

{

const CTransaction& tx = *btck_Transaction::get(transaction);

assert(output_index < tx.vout.size());

return btck_TransactionOutput::ref(&tx.vout[output_index]);

}

size_t btck_transaction_count_inputs(const btck_Transaction* transaction)

{

return btck_Transaction::get(transaction)->vin.size();

}

const btck_TransactionInput* btck_transaction_get_input_at(const btck_Transaction* transaction, size_t input_index)

{

assert(input_index < btck_Transaction::get(transaction)->vin.size());

return btck_TransactionInput::ref(&btck_Transaction::get(transaction)->vin[input_index]);

}

uint32_t btck_transaction_get_locktime(const btck_Transaction* transaction)

{

return btck_Transaction::get(transaction)->nLockTime;

}

const btck_Txid* btck_transaction_get_txid(const btck_Transaction* transaction)

{

return btck_Txid::ref(&btck_Transaction::get(transaction)->GetHash());

}

btck_Transaction* btck_transaction_copy(const btck_Transaction* transaction)

{

return btck_Transaction::copy(transaction);

}

int btck_transaction_to_bytes(const btck_Transaction* transaction, btck_WriteBytes writer, void* user_data)

}

void btck_transaction_destroy(btck_Transaction* transaction)

{

delete transaction;

}

btck_ScriptPubkey* btck_script_pubkey_create(const void* script_pubkey, size_t script_pubkey_len)

{

if (script_pubkey == nullptr && script_pubkey_len != 0) {

return nullptr;

}

auto data = std::span{reinterpret_cast<const uint8_t*>(script_pubkey), script_pubkey_len};

return btck_ScriptPubkey::create(data.begin(), data.end());

}

int btck_script_pubkey_to_bytes(const btck_ScriptPubkey* script_pubkey_, btck_WriteBytes writer, void* user_data)

}

btck_ScriptPubkey* btck_script_pubkey_copy(const btck_ScriptPubkey* script_pubkey)

{

return btck_ScriptPubkey::copy(script_pubkey);

}

void btck_script_pubkey_destroy(btck_ScriptPubkey* script_pubkey)

{

delete script_pubkey;

}

btck_TransactionOutput* btck_transaction_output_create(const btck_ScriptPubkey* script_pubkey, int64_t amount)

{

return btck_TransactionOutput::create(amount, btck_ScriptPubkey::get(script_pubkey));

}

btck_TransactionOutput* btck_transaction_output_copy(const btck_TransactionOutput* output)

{

return btck_TransactionOutput::copy(output);

}

const btck_ScriptPubkey* btck_transaction_output_get_script_pubkey(const btck_TransactionOutput* output)

{

return btck_ScriptPubkey::ref(&btck_TransactionOutput::get(output).scriptPubKey);

}

int64_t btck_transaction_output_get_amount(const btck_TransactionOutput* output)

{

return btck_TransactionOutput::get(output).nValue;

}

void btck_transaction_output_destroy(btck_TransactionOutput* output)

{

delete output;

}

btck_PrecomputedTransactionData* btck_precomputed_transaction_data_create(

const btck_Transaction* tx_to,

const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len)

{

try {

const CTransaction& tx{*btck_Transaction::get(tx_to)};

auto txdata{btck_PrecomputedTransactionData::create()};

if (spent_outputs_ != nullptr && spent_outputs_len > 0) {

assert(spent_outputs_len == tx.vin.size());

std::vector<CTxOut> spent_outputs;

spent_outputs.reserve(spent_outputs_len);

for (size_t i = 0; i < spent_outputs_len; i++) {

const CTxOut& tx_out{btck_TransactionOutput::get(spent_outputs_[i])};

spent_outputs.push_back(tx_out);

}

btck_PrecomputedTransactionData::get(txdata).Init(tx, std::move(spent_outputs));

} else {

btck_PrecomputedTransactionData::get(txdata).Init(tx, {});

}

return txdata;

} catch (...) {

return nullptr;

}

}

btck_PrecomputedTransactionData* btck_precomputed_transaction_data_copy(const btck_PrecomputedTransactionData* precomputed_txdata)

{

return btck_PrecomputedTransactionData::copy(precomputed_txdata);

}

void btck_precomputed_transaction_data_destroy(btck_PrecomputedTransactionData* precomputed_txdata)

{

delete precomputed_txdata;

}

int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,

}

btck_TransactionInput* btck_transaction_input_copy(const btck_TransactionInput* input)

{

return btck_TransactionInput::copy(input);

}

const btck_TransactionOutPoint* btck_transaction_input_get_out_point(const btck_TransactionInput* input)

{

return btck_TransactionOutPoint::ref(&btck_TransactionInput::get(input).prevout);

}

uint32_t btck_transaction_input_get_sequence(const btck_TransactionInput* input)

{

return btck_TransactionInput::get(input).nSequence;

}

void btck_transaction_input_destroy(btck_TransactionInput* input)

{

delete input;

}

btck_TransactionOutPoint* btck_transaction_out_point_copy(const btck_TransactionOutPoint* out_point)

{

return btck_TransactionOutPoint::copy(out_point);

}

uint32_t btck_transaction_out_point_get_index(const btck_TransactionOutPoint* out_point)

{

return btck_TransactionOutPoint::get(out_point).n;

}

const btck_Txid* btck_transaction_out_point_get_txid(const btck_TransactionOutPoint* out_point)

{

return btck_Txid::ref(&btck_TransactionOutPoint::get(out_point).hash);

}

void btck_transaction_out_point_destroy(btck_TransactionOutPoint* out_point)

{

delete out_point;

}

btck_Txid* btck_txid_copy(const btck_Txid* txid)

{

return btck_Txid::copy(txid);

}

void btck_txid_to_bytes(const btck_Txid* txid, unsigned char output[32])

{

std::memcpy(output, btck_Txid::get(txid).begin(), 32);

}

int btck_txid_equals(const btck_Txid* txid1, const btck_Txid* txid2)

{

return btck_Txid::get(txid1) == btck_Txid::get(txid2);

}

void btck_txid_destroy(btck_Txid* txid)

{

delete txid;

}

void btck_logging_set_options(const btck_LoggingOptions options)

}

void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)

}

void btck_logging_enable_category(btck_LogCategory category)

{

LogInstance().EnableCategory(get_bclog_flag(category));

}

void btck_logging_disable_category(btck_LogCategory category)

{

LogInstance().DisableCategory(get_bclog_flag(category));

}

void btck_logging_disable()

{

LogInstance().DisableLogging();

}

btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)

{

try {

return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback);

} catch (const std::exception&) {

return nullptr;

}

}

void btck_logging_connection_destroy(btck_LoggingConnection* connection)

{

delete connection;

}

btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)

{

switch (chain_type) {

case btck_ChainType_MAINNET: {

return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::Main().release()));

}

case btck_ChainType_TESTNET: {

return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet().release()));

}

case btck_ChainType_TESTNET_4: {

return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::TestNet4().release()));

}

case btck_ChainType_SIGNET: {

return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::SigNet({}).release()));

}

case btck_ChainType_REGTEST: {

return btck_ChainParameters::ref(const_cast<CChainParams*>(CChainParams::RegTest({}).release()));

}

}

assert(false);

}

btck_ChainParameters* btck_chain_parameters_copy(const btck_ChainParameters* chain_parameters)

{

return btck_ChainParameters::copy(chain_parameters);

}

void btck_chain_parameters_destroy(btck_ChainParameters* chain_parameters)

{

delete chain_parameters;

}

btck_ContextOptions* btck_context_options_create()

{

return btck_ContextOptions::create();

}

void btck_context_options_set_chainparams(btck_ContextOptions* options, const btck_ChainParameters* chain_parameters)

}

void btck_context_options_set_notifications(btck_ContextOptions* options, btck_NotificationInterfaceCallbacks notifications)

}

void btck_context_options_set_validation_interface(btck_ContextOptions* options, btck_ValidationInterfaceCallbacks vi_cbs)

}

void btck_context_options_destroy(btck_ContextOptions* options)

{

delete options;

}

btck_Context* btck_context_create(const btck_ContextOptions* options)

{

bool sane{true};

const ContextOptions* opts = options ? &btck_ContextOptions::get(options) : nullptr;

auto context{std::make_shared<const Context>(opts, sane)};

if (!sane) {

LogError("Kernel context sanity check failed.");

return nullptr;

}

return btck_Context::create(context);

}

btck_Context* btck_context_copy(const btck_Context* context)

{

return btck_Context::copy(context);

}

int btck_context_interrupt(btck_Context* context)

{

return (*btck_Context::get(context)->m_interrupt)() ? 0 : -1;

}

void btck_context_destroy(btck_Context* context)

{

delete context;

}

const btck_BlockTreeEntry* btck_block_tree_entry_get_previous(const btck_BlockTreeEntry* entry)

{

if (!btck_BlockTreeEntry::get(entry).pprev) {

LogInfo("Genesis block has no previous.");

return nullptr;

}

return btck_BlockTreeEntry::ref(btck_BlockTreeEntry::get(entry).pprev);

}

btck_BlockValidationState* btck_block_validation_state_create()

{

return btck_BlockValidationState::create();

}

btck_BlockValidationState* btck_block_validation_state_copy(const btck_BlockValidationState* state)

{

return btck_BlockValidationState::copy(state);

}

void btck_block_validation_state_destroy(btck_BlockValidationState* state)

{

delete state;

}

btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)

}

btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState* block_validation_state_)

}

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)

{

if (data_dir == nullptr || data_dir_len == 0 || blocks_dir == nullptr || blocks_dir_len == 0) {

LogError("Failed to create chainstate manager options: dir must be non-null and non-empty");

return nullptr;

}

try {

fs::path abs_data_dir{fs::absolute(fs::PathFromString({data_dir, data_dir_len}))};

fs::create_directories(abs_data_dir);

fs::path abs_blocks_dir{fs::absolute(fs::PathFromString({blocks_dir, blocks_dir_len}))};

fs::create_directories(abs_blocks_dir);

return btck_ChainstateManagerOptions::create(btck_Context::get(context), abs_data_dir, abs_blocks_dir);

} catch (const std::exception& e) {

LogError("Failed to create chainstate manager options: %s", e.what());

return nullptr;

}

}

void btck_chainstate_manager_options_set_worker_threads_num(btck_ChainstateManagerOptions* opts, int worker_threads)

}

void btck_chainstate_manager_options_destroy(btck_ChainstateManagerOptions* options)

{

delete options;

}

int btck_chainstate_manager_options_set_wipe_dbs(btck_ChainstateManagerOptions* chainman_opts, int wipe_block_tree_db, int wipe_chainstate_db)

}

void btck_chainstate_manager_options_update_block_tree_db_in_memory(

}

void btck_chainstate_manager_options_update_chainstate_db_in_memory(