bitcoinkernel_wrapper.h

Go to the documentation of this file.

// 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_WRAPPER_H
#define BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H
 
#include <kernel/bitcoinkernel.h>
 
#include <array>
#include <chrono>
#include <exception>
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace btck {
 
enum class LogCategory : btck_LogCategory {
    NONE = btck_LogCategory_NONE,
    BENCH = btck_LogCategory_BENCH,
    BLOCKSTORAGE = btck_LogCategory_BLOCKSTORAGE,
    COINDB = btck_LogCategory_COINDB,
    LEVELDB = btck_LogCategory_LEVELDB,
    MEMPOOL = btck_LogCategory_MEMPOOL,
    PRUNE = btck_LogCategory_PRUNE,
    RAND = btck_LogCategory_RAND,
    REINDEX = btck_LogCategory_REINDEX,
    VALIDATION = btck_LogCategory_VALIDATION,
    KERNEL = btck_LogCategory_KERNEL,
    TXPACKAGES = btck_LogCategory_TXPACKAGES,
    LOCK = btck_LogCategory_LOCK,
};
 
enum class LogLevel : btck_LogLevel {
    TRACE_LEVEL = btck_LogLevel_TRACE,
    DEBUG_LEVEL = btck_LogLevel_DEBUG,
    INFO_LEVEL = btck_LogLevel_INFO,
    WARNING_LEVEL = btck_LogLevel_WARNING,
    ERROR_LEVEL = btck_LogLevel_ERROR,
};
 
constexpr std::string_view Name(LogLevel level) noexcept
{
    switch (level) {
    case LogLevel::TRACE_LEVEL: return "trace";
    case LogLevel::DEBUG_LEVEL: return "debug";
    case LogLevel::INFO_LEVEL: return "info";
    case LogLevel::WARNING_LEVEL: return "warning";
    case LogLevel::ERROR_LEVEL: return "error";
    } // no default case, so the compiler can warn about missing cases
    return "unknown";
}
 
constexpr std::string_view Name(LogCategory category) noexcept
{
    switch (category) {
    case LogCategory::NONE: return "none";
    case LogCategory::BENCH: return "bench";
    case LogCategory::BLOCKSTORAGE: return "blockstorage";
    case LogCategory::COINDB: return "coindb";
    case LogCategory::LEVELDB: return "leveldb";
    case LogCategory::MEMPOOL: return "mempool";
    case LogCategory::PRUNE: return "prune";
    case LogCategory::RAND: return "rand";
    case LogCategory::REINDEX: return "reindex";
    case LogCategory::TXPACKAGES: return "txpackages";
    case LogCategory::VALIDATION: return "validation";
    case LogCategory::KERNEL: return "kernel";
    case LogCategory::LOCK: return "lock";
    } // no default case, so the compiler can warn about missing cases
    return "unknown";
}
 
enum class ChainType : btck_ChainType {
    MAINNET = btck_ChainType_MAINNET,
    TESTNET = btck_ChainType_TESTNET,
    TESTNET_4 = btck_ChainType_TESTNET_4,
    SIGNET = btck_ChainType_SIGNET,
    REGTEST = btck_ChainType_REGTEST
};
 
enum class SynchronizationState : btck_SynchronizationState {
    INIT_REINDEX = btck_SynchronizationState_INIT_REINDEX,
    INIT_DOWNLOAD = btck_SynchronizationState_INIT_DOWNLOAD,
    POST_INIT = btck_SynchronizationState_POST_INIT
};
 
enum class Warning : btck_Warning {
    UNKNOWN_NEW_RULES_ACTIVATED = btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED,
    LARGE_WORK_INVALID_CHAIN = btck_Warning_LARGE_WORK_INVALID_CHAIN
};
 
enum class ValidationMode : btck_ValidationMode {
    VALID = btck_ValidationMode_VALID,
    INVALID = btck_ValidationMode_INVALID,
    INTERNAL_ERROR = btck_ValidationMode_INTERNAL_ERROR
};
 
enum class BlockValidationResult : btck_BlockValidationResult {
    UNSET = btck_BlockValidationResult_UNSET,
    CONSENSUS = btck_BlockValidationResult_CONSENSUS,
    CACHED_INVALID = btck_BlockValidationResult_CACHED_INVALID,
    INVALID_HEADER = btck_BlockValidationResult_INVALID_HEADER,
    MUTATED = btck_BlockValidationResult_MUTATED,
    MISSING_PREV = btck_BlockValidationResult_MISSING_PREV,
    INVALID_PREV = btck_BlockValidationResult_INVALID_PREV,
    TIME_FUTURE = btck_BlockValidationResult_TIME_FUTURE,
    HEADER_LOW_WORK = btck_BlockValidationResult_HEADER_LOW_WORK
};
 
enum class TxValidationResult : btck_TxValidationResult {
    UNSET               = btck_TxValidationResult_UNSET,
    CONSENSUS           = btck_TxValidationResult_CONSENSUS,
    INPUTS_NOT_STANDARD = btck_TxValidationResult_INPUTS_NOT_STANDARD,
    NOT_STANDARD        = btck_TxValidationResult_NOT_STANDARD,
    MISSING_INPUTS      = btck_TxValidationResult_MISSING_INPUTS,
    PREMATURE_SPEND     = btck_TxValidationResult_PREMATURE_SPEND,
    WITNESS_MUTATED     = btck_TxValidationResult_WITNESS_MUTATED,
    WITNESS_STRIPPED    = btck_TxValidationResult_WITNESS_STRIPPED,
    CONFLICT            = btck_TxValidationResult_CONFLICT,
    MEMPOOL_POLICY      = btck_TxValidationResult_MEMPOOL_POLICY,
    NO_MEMPOOL          = btck_TxValidationResult_NO_MEMPOOL,
    RECONSIDERABLE      = btck_TxValidationResult_RECONSIDERABLE,
    UNKNOWN             = btck_TxValidationResult_UNKNOWN
};
 
enum class ScriptVerifyStatus : btck_ScriptVerifyStatus {
    OK = btck_ScriptVerifyStatus_OK,
    ERROR_INVALID_FLAGS_COMBINATION = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION,
    ERROR_SPENT_OUTPUTS_REQUIRED = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED,
};
 
enum class ScriptVerificationFlags : btck_ScriptVerificationFlags {
    NONE = btck_ScriptVerificationFlags_NONE,
    P2SH = btck_ScriptVerificationFlags_P2SH,
    DERSIG = btck_ScriptVerificationFlags_DERSIG,
    NULLDUMMY = btck_ScriptVerificationFlags_NULLDUMMY,
    CHECKLOCKTIMEVERIFY = btck_ScriptVerificationFlags_CHECKLOCKTIMEVERIFY,
    CHECKSEQUENCEVERIFY = btck_ScriptVerificationFlags_CHECKSEQUENCEVERIFY,
    WITNESS = btck_ScriptVerificationFlags_WITNESS,
    TAPROOT = btck_ScriptVerificationFlags_TAPROOT,
    ALL = btck_ScriptVerificationFlags_ALL
};
 
enum class BlockCheckFlags : btck_BlockCheckFlags {
    BASE = btck_BlockCheckFlags_BASE,
    POW = btck_BlockCheckFlags_POW,
    MERKLE = btck_BlockCheckFlags_MERKLE,
    ALL = btck_BlockCheckFlags_ALL
};
 
template <typename T>
struct is_bitmask_enum : std::false_type {
};
 
template <>
struct is_bitmask_enum<ScriptVerificationFlags> : std::true_type {
};
 
template <>
struct is_bitmask_enum<BlockCheckFlags> : std::true_type {
};
 
template <typename T>
concept BitmaskEnum = is_bitmask_enum<T>::value;
 
template <BitmaskEnum T>
constexpr T operator|(T lhs, T rhs)
{
    return static_cast<T>(
        static_cast<std::underlying_type_t<T>>(lhs) | static_cast<std::underlying_type_t<T>>(rhs));
}
 
template <BitmaskEnum T>
constexpr T operator&(T lhs, T rhs)
{
    return static_cast<T>(
        static_cast<std::underlying_type_t<T>>(lhs) & static_cast<std::underlying_type_t<T>>(rhs));
}
 
template <BitmaskEnum T>
constexpr T operator^(T lhs, T rhs)
{
    return static_cast<T>(
        static_cast<std::underlying_type_t<T>>(lhs) ^ static_cast<std::underlying_type_t<T>>(rhs));
}
 
template <BitmaskEnum T>
constexpr T operator~(T value)
{
    return static_cast<T>(~static_cast<std::underlying_type_t<T>>(value));
}
 
template <BitmaskEnum T>
constexpr T& operator|=(T& lhs, T rhs)
{
    return lhs = lhs | rhs;
}
 
template <BitmaskEnum T>
constexpr T& operator&=(T& lhs, T rhs)
{
    return lhs = lhs & rhs;
}
 
template <BitmaskEnum T>
constexpr T& operator^=(T& lhs, T rhs)
{
    return lhs = lhs ^ rhs;
}
 
template <typename T>
T check(T ptr)
{
    if (ptr == nullptr) {
        throw std::runtime_error("failed to instantiate btck object");
    }
    return ptr;
}
 
template <typename Collection, typename ValueType, auto GetFunc>
class Iterator
{
public:
    using iterator_category = std::random_access_iterator_tag;
    using iterator_concept = std::random_access_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = ValueType;
 
private:
    const Collection* m_collection;
    size_t m_idx;
 
public:
    Iterator() = default;
    Iterator(const Collection* ptr) : m_collection{ptr}, m_idx{0} {}
    Iterator(const Collection* ptr, size_t idx) : m_collection{ptr}, m_idx{idx} {}
 
    // This is just a view, so return a copy.
    auto operator*() const { return std::invoke(GetFunc, *m_collection, m_idx); }
 
    auto& operator++() { m_idx++; return *this; }
    auto operator++(int) { Iterator tmp = *this; ++(*this); return tmp; }
 
    auto& operator--() { m_idx--; return *this; }
    auto operator--(int) { auto temp = *this; --m_idx; return temp; }
 
    auto& operator+=(difference_type n) { m_idx += n; return *this; }
    auto& operator-=(difference_type n) { m_idx -= n; return *this; }
 
    auto operator+(difference_type n) const { return Iterator(m_collection, m_idx + n); }
    auto operator-(difference_type n) const { return Iterator(m_collection, m_idx - n); }
 
    auto operator-(const Iterator& other) const { return static_cast<difference_type>(m_idx) - static_cast<difference_type>(other.m_idx); }
 
    ValueType operator[](difference_type n) const { return *(*this + n); }
 
    auto operator<=>(const Iterator& other) const { return m_idx <=> other.m_idx; }
 
    bool operator==(const Iterator& other) const { return m_collection == other.m_collection && m_idx == other.m_idx; }
 
private:
    friend Iterator operator+(difference_type n, const Iterator& it) { return it + n; }
};
 
template <typename Container, typename SizeFunc, typename GetFunc>
concept IndexedContainer = requires(const Container& c, SizeFunc size_func, GetFunc get_func, std::size_t i) {
    { std::invoke(size_func, c) } -> std::convertible_to<std::size_t>;
    { std::invoke(get_func, c, i) }; // Return type is deduced
};
 
template <typename Container, auto SizeFunc, auto GetFunc>
    requires IndexedContainer<Container, decltype(SizeFunc), decltype(GetFunc)>
class Range
{
public:
    using value_type = std::invoke_result_t<decltype(GetFunc), const Container&, size_t>;
    using difference_type = std::ptrdiff_t;
    using iterator = Iterator<Container, value_type, GetFunc>;
    using const_iterator = iterator;
 
private:
    const Container* m_container;
 
public:
    explicit Range(const Container& container) : m_container(&container)
    {
        static_assert(std::ranges::random_access_range<Range>);
    }
 
    iterator begin() const { return iterator(m_container, 0); }
    iterator end() const { return iterator(m_container, size()); }
 
    const_iterator cbegin() const { return begin(); }
    const_iterator cend() const { return end(); }
 
    size_t size() const { return std::invoke(SizeFunc, *m_container); }
 
    bool empty() const { return size() == 0; }
 
    value_type operator[](size_t index) const { return std::invoke(GetFunc, *m_container, index); }
 
    value_type at(size_t index) const
    {
        if (index >= size()) {
            throw std::out_of_range("Index out of range");
        }
        return (*this)[index];
    }
 
    value_type front() const { return (*this)[0]; }
    value_type back() const { return (*this)[size() - 1]; }
};
 
#define MAKE_RANGE_METHOD(method_name, ContainerType, SizeFunc, GetFunc, container_expr) \
    auto method_name() const & { \
        return Range<ContainerType, SizeFunc, GetFunc>{container_expr}; \
    } \
    auto method_name() const && = delete;
 
template <typename T>
std::vector<std::byte> write_bytes(const T* object, int (*to_bytes)(const T*, btck_WriteBytes, void*))
{
    std::vector<std::byte> bytes;
    struct UserData {
        std::vector<std::byte>* bytes;
        std::exception_ptr exception;
    };
    UserData user_data = UserData{.bytes = &bytes, .exception = nullptr};
 
    constexpr auto const write = +[](const void* buffer, size_t len, void* user_data) -> int {
        auto& data = *reinterpret_cast<UserData*>(user_data);
        auto& bytes = *data.bytes;
        try {
            auto const* first = static_cast<const std::byte*>(buffer);
            auto const* last = first + len;
            bytes.insert(bytes.end(), first, last);
            return 0;
        } catch (...) {
            data.exception = std::current_exception();
            return -1;
        }
    };
 
    if (to_bytes(object, write, &user_data) != 0) {
        std::rethrow_exception(user_data.exception);
    }
    return bytes;
}
 
template <typename CType>
class View
{
protected:
    const CType* m_ptr;
 
public:
    explicit View(const CType* ptr) : m_ptr{check(ptr)} {}
 
    const CType* get() const { return m_ptr; }
};
 
template <typename CType, CType* (*CopyFunc)(const CType*), void (*DestroyFunc)(CType*)>
class Handle
{
protected:
    CType* m_ptr;
 
public:
    explicit Handle(CType* ptr) : m_ptr{check(ptr)} {}
 
    // Copy constructors
    Handle(const Handle& other)
        : m_ptr{check(CopyFunc(other.m_ptr))} {}
    Handle& operator=(const Handle& other)
    {
        if (this != &other) {
            Handle temp(other);
            std::swap(m_ptr, temp.m_ptr);
        }
        return *this;
    }
 
    // Move constructors
    Handle(Handle&& other) noexcept : m_ptr(other.m_ptr) { other.m_ptr = nullptr; }
    Handle& operator=(Handle&& other) noexcept
    {
        if (this != &other) {
            DestroyFunc(m_ptr);
            m_ptr = std::exchange(other.m_ptr, nullptr);
        }
        return *this;
    }
 
    template <typename ViewType>
        requires std::derived_from<ViewType, View<CType>>
    Handle(const ViewType& view)
        : Handle{CopyFunc(view.get())}
    {
    }
 
    ~Handle() { DestroyFunc(m_ptr); }
 
    CType* get() { return m_ptr; }
    const CType* get() const { return m_ptr; }
};
 
template <typename CType, void (*DestroyFunc)(CType*)>
class UniqueHandle
{
protected:
    struct Deleter {
        void operator()(CType* ptr) const noexcept
        {
            if (ptr) DestroyFunc(ptr);
        }
    };
    std::unique_ptr<CType, Deleter> m_ptr;
 
public:
    explicit UniqueHandle(CType* ptr) : m_ptr{check(ptr)} {}
 
    CType* get() { return m_ptr.get(); }
    const CType* get() const { return m_ptr.get(); }
};
 
class PrecomputedTransactionData;
class Transaction;
class TransactionOutput;
class BlockValidationState;
 
template <typename Derived>
class ScriptPubkeyApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    ScriptPubkeyApi() = default;
 
public:
    bool Verify(int64_t amount,
                const Transaction& tx_to,
                const PrecomputedTransactionData* precomputed_txdata,
                unsigned int input_index,
                ScriptVerificationFlags flags,
                ScriptVerifyStatus& status) const;
 
    std::vector<std::byte> ToBytes() const
    {
        return write_bytes(impl(), btck_script_pubkey_to_bytes);
    }
};
 
class ScriptPubkeyView : public View<btck_ScriptPubkey>, public ScriptPubkeyApi<ScriptPubkeyView>
{
public:
    explicit ScriptPubkeyView(const btck_ScriptPubkey* ptr) : View{ptr} {}
};
 
class ScriptPubkey : public Handle<btck_ScriptPubkey, btck_script_pubkey_copy, btck_script_pubkey_destroy>, public ScriptPubkeyApi<ScriptPubkey>
{
public:
    explicit ScriptPubkey(std::span<const std::byte> raw)
        : Handle{btck_script_pubkey_create(raw.data(), raw.size())} {}
 
    ScriptPubkey(const ScriptPubkeyView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class TransactionOutputApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    TransactionOutputApi() = default;
 
public:
    int64_t Amount() const
    {
        return btck_transaction_output_get_amount(impl());
    }
 
    ScriptPubkeyView GetScriptPubkey() const
    {
        return ScriptPubkeyView{btck_transaction_output_get_script_pubkey(impl())};
    }
};
 
class TransactionOutputView : public View<btck_TransactionOutput>, public TransactionOutputApi<TransactionOutputView>
{
public:
    explicit TransactionOutputView(const btck_TransactionOutput* ptr) : View{ptr} {}
};
 
class TransactionOutput : public Handle<btck_TransactionOutput, btck_transaction_output_copy, btck_transaction_output_destroy>, public TransactionOutputApi<TransactionOutput>
{
public:
    explicit TransactionOutput(const ScriptPubkey& script_pubkey, int64_t amount)
        : Handle{btck_transaction_output_create(script_pubkey.get(), amount)} {}
 
    TransactionOutput(const TransactionOutputView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class TxidApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    TxidApi() = default;
 
public:
    bool operator==(const TxidApi& other) const
    {
        return btck_txid_equals(impl(), other.impl()) != 0;
    }
 
    bool operator!=(const TxidApi& other) const
    {
        return btck_txid_equals(impl(), other.impl()) == 0;
    }
 
    std::array<std::byte, 32> ToBytes() const
    {
        std::array<std::byte, 32> hash;
        btck_txid_to_bytes(impl(), reinterpret_cast<unsigned char*>(hash.data()));
        return hash;
    }
};
 
class TxidView : public View<btck_Txid>, public TxidApi<TxidView>
{
public:
    explicit TxidView(const btck_Txid* ptr) : View{ptr} {}
};
 
class Txid : public Handle<btck_Txid, btck_txid_copy, btck_txid_destroy>, public TxidApi<Txid>
{
public:
    Txid(const TxidView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class WtxidApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    WtxidApi() = default;
 
public:
    bool operator==(const WtxidApi& other) const
    {
        return btck_wtxid_equals(impl(), other.impl()) != 0;
    }
 
    bool operator!=(const WtxidApi& other) const
    {
        return btck_wtxid_equals(impl(), other.impl()) == 0;
    }
 
    std::array<std::byte, 32> ToBytes() const
    {
        std::array<std::byte, 32> hash;
        btck_wtxid_to_bytes(impl(), reinterpret_cast<unsigned char*>(hash.data()));
        return hash;
    }
};
 
class WtxidView : public View<btck_Wtxid>, public WtxidApi<WtxidView>
{
public:
    explicit WtxidView(const btck_Wtxid* ptr) : View{ptr} {}
};
 
class Wtxid : public Handle<btck_Wtxid, btck_wtxid_copy, btck_wtxid_destroy>, public WtxidApi<Wtxid>
{
public:
    Wtxid(const WtxidView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class OutPointApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    OutPointApi() = default;
 
public:
    uint32_t index() const
    {
        return btck_transaction_out_point_get_index(impl());
    }
 
    TxidView Txid() const
    {
        return TxidView{btck_transaction_out_point_get_txid(impl())};
    }
};
 
class OutPointView : public View<btck_TransactionOutPoint>, public OutPointApi<OutPointView>
{
public:
    explicit OutPointView(const btck_TransactionOutPoint* ptr) : View{ptr} {}
};
 
class OutPoint : public Handle<btck_TransactionOutPoint, btck_transaction_out_point_copy, btck_transaction_out_point_destroy>, public OutPointApi<OutPoint>
{
public:
    OutPoint(const OutPointView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class WitnessStackApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    WitnessStackApi() = default;
 
public:
    size_t CountItems() const
    {
        return btck_witness_stack_count_items(impl());
    }
 
    std::vector<std::byte> GetItem(size_t index) const
    {
        struct Item { const btck_WitnessStack* stack; size_t index; };
        Item item{impl(), index};
        return write_bytes(&item, +[](const Item* c, btck_WriteBytes w, void* ud) {
            return btck_witness_stack_get_item_at(c->stack, c->index, w, ud);
        });
    }
 
    MAKE_RANGE_METHOD(Items, Derived, &WitnessStackApi<Derived>::CountItems, &WitnessStackApi<Derived>::GetItem, *static_cast<const Derived*>(this))
};
 
class WitnessStackView : public View<btck_WitnessStack>, public WitnessStackApi<WitnessStackView>
{
public:
    explicit WitnessStackView(const btck_WitnessStack* ptr) : View{ptr} {}
};
 
class WitnessStack : public Handle<btck_WitnessStack, btck_witness_stack_copy, btck_witness_stack_destroy>, public WitnessStackApi<WitnessStack>
{
public:
    WitnessStack(const WitnessStackView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class TransactionInputApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    TransactionInputApi() = default;
 
public:
    OutPointView OutPoint() const
    {
        return OutPointView{btck_transaction_input_get_out_point(impl())};
    }
 
    uint32_t GetSequence() const
    {
        return btck_transaction_input_get_sequence(impl());
    }
 
    WitnessStackView GetWitnessStack() const
    {
        return WitnessStackView{btck_transaction_input_get_witness_stack(impl())};
    }
 
    std::vector<std::byte> GetScriptSig() const
    {
        return write_bytes(impl(), btck_transaction_input_get_script_sig);
    }
};
 
class TransactionInputView : public View<btck_TransactionInput>, public TransactionInputApi<TransactionInputView>
{
public:
    explicit TransactionInputView(const btck_TransactionInput* ptr) : View{ptr} {}
};
 
class TransactionInput : public Handle<btck_TransactionInput, btck_transaction_input_copy, btck_transaction_input_destroy>, public TransactionInputApi<TransactionInput>
{
public:
    TransactionInput(const TransactionInputView& view)
        : Handle(view) {}
};
 
template <typename Derived>
class TransactionApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
public:
    size_t CountOutputs() const
    {
        return btck_transaction_count_outputs(impl());
    }
 
    size_t CountInputs() const
    {
        return btck_transaction_count_inputs(impl());
    }
 
    TransactionOutputView GetOutput(size_t index) const
    {
        return TransactionOutputView{btck_transaction_get_output_at(impl(), index)};
    }
 
    TransactionInputView GetInput(size_t index) const
    {
        return TransactionInputView{btck_transaction_get_input_at(impl(), index)};
    }
 
    uint32_t GetVersion() const
    {
        return btck_transaction_get_version(impl());
    }
 
    uint32_t GetLocktime() const
    {
        return btck_transaction_get_locktime(impl());
    }
 
    bool HasWitness() const
    {
        return btck_transaction_has_witness(impl()) != 0;
    }
 
    TxidView Txid() const
    {
        return TxidView{btck_transaction_get_txid(impl())};
    }
 
    WtxidView Wtxid() const
    {
        return WtxidView{btck_transaction_get_wtxid(impl())};
    }
 
    MAKE_RANGE_METHOD(Outputs, Derived, &TransactionApi<Derived>::CountOutputs, &TransactionApi<Derived>::GetOutput, *static_cast<const Derived*>(this))
 
    MAKE_RANGE_METHOD(Inputs, Derived, &TransactionApi<Derived>::CountInputs, &TransactionApi<Derived>::GetInput, *static_cast<const Derived*>(this))
 
    std::vector<std::byte> ToBytes() const
    {
        return write_bytes(impl(), btck_transaction_to_bytes);
    }
};
 
class TransactionView : public View<btck_Transaction>, public TransactionApi<TransactionView>
{
public:
    explicit TransactionView(const btck_Transaction* ptr) : View{ptr} {}
};
 
class Transaction : public Handle<btck_Transaction, btck_transaction_copy, btck_transaction_destroy>, public TransactionApi<Transaction>
{
public:
    explicit Transaction(std::span<const std::byte> raw_transaction)
        : Handle{btck_transaction_create(raw_transaction.data(), raw_transaction.size())} {}
 
    Transaction(const TransactionView& view)
        : Handle{view} {}
};
 
class PrecomputedTransactionData : public Handle<btck_PrecomputedTransactionData, btck_precomputed_transaction_data_copy, btck_precomputed_transaction_data_destroy>
{
public:
    explicit PrecomputedTransactionData(const Transaction& tx_to, std::span<const TransactionOutput> spent_outputs)
        : Handle{btck_precomputed_transaction_data_create(
            tx_to.get(),
            reinterpret_cast<const btck_TransactionOutput**>(
                const_cast<TransactionOutput*>(spent_outputs.data())),
            spent_outputs.size())} {}
};
 
template <typename Derived>
bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
                                      const Transaction& tx_to,
                                      const PrecomputedTransactionData* precomputed_txdata,
                                      unsigned int input_index,
                                      ScriptVerificationFlags flags,
                                      ScriptVerifyStatus& status) const
{
    auto result = btck_script_pubkey_verify(
        impl(),
        amount,
        tx_to.get(),
        precomputed_txdata ? precomputed_txdata->get() : nullptr,
        input_index,
        static_cast<btck_ScriptVerificationFlags>(flags),
        reinterpret_cast<btck_ScriptVerifyStatus*>(&status));
    return result == 1;
}
 
template <typename Derived>
class BlockHashApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
public:
    bool operator==(const Derived& other) const
    {
        return btck_block_hash_equals(impl(), other.get()) != 0;
    }
 
    bool operator!=(const Derived& other) const
    {
        return btck_block_hash_equals(impl(), other.get()) == 0;
    }
 
    std::array<std::byte, 32> ToBytes() const
    {
        std::array<std::byte, 32> hash;
        btck_block_hash_to_bytes(impl(), reinterpret_cast<unsigned char*>(hash.data()));
        return hash;
    }
};
 
class BlockHashView : public View<btck_BlockHash>, public BlockHashApi<BlockHashView>
{
public:
    explicit BlockHashView(const btck_BlockHash* ptr) : View{ptr} {}
};
 
class BlockHash : public Handle<btck_BlockHash, btck_block_hash_copy, btck_block_hash_destroy>, public BlockHashApi<BlockHash>
{
public:
    explicit BlockHash(const std::array<std::byte, 32>& hash)
        : Handle{btck_block_hash_create(reinterpret_cast<const unsigned char*>(hash.data()))} {}
 
    explicit BlockHash(btck_BlockHash* hash)
        : Handle{hash} {}
 
    BlockHash(const BlockHashView& view)
        : Handle{view} {}
};
 
template <typename Derived>
class BlockHeaderApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    BlockHeaderApi() = default;
 
public:
    BlockHash Hash() const
    {
        return BlockHash{btck_block_header_get_hash(impl())};
    }
 
    BlockHashView PrevHash() const
    {
        return BlockHashView{btck_block_header_get_prev_hash(impl())};
    }
 
    std::array<std::byte, 32> MerkleRoot() const
    {
        std::array<std::byte, 32> merkle_root;
        btck_block_header_get_merkle_root(impl(), reinterpret_cast<unsigned char*>(merkle_root.data()));
        return merkle_root;
    }
 
    uint32_t Timestamp() const
    {
        return btck_block_header_get_timestamp(impl());
    }
 
    uint32_t Bits() const
    {
        return btck_block_header_get_bits(impl());
    }
 
    int32_t Version() const
    {
        return btck_block_header_get_version(impl());
    }
 
    uint32_t Nonce() const
    {
        return btck_block_header_get_nonce(impl());
    }
 
    std::array<std::byte, 80> ToBytes() const
    {
        std::array<std::byte, 80> header;
        int res{btck_block_header_to_bytes(impl(), reinterpret_cast<unsigned char*>(header.data()))};
        if (res != 0) {
            throw std::runtime_error("Failed to serialize block header");
        }
        return header;
    }
};
 
class BlockHeaderView : public View<btck_BlockHeader>, public BlockHeaderApi<BlockHeaderView>
{
public:
    explicit BlockHeaderView(const btck_BlockHeader* ptr) : View{ptr} {}
};
 
class BlockHeader : public Handle<btck_BlockHeader, btck_block_header_copy, btck_block_header_destroy>, public BlockHeaderApi<BlockHeader>
{
public:
    explicit BlockHeader(std::span<const std::byte> raw_header)
        : Handle{btck_block_header_create(reinterpret_cast<const unsigned char*>(raw_header.data()), raw_header.size())} {}
 
    BlockHeader(const BlockHeaderView& view)
        : Handle{view} {}
 
    BlockHeader(btck_BlockHeader* header)
        : Handle{header} {}
};
 
class ConsensusParamsView : public View<btck_ConsensusParams>
{
public:
    explicit ConsensusParamsView(const btck_ConsensusParams* ptr) : View{ptr} {}
};
 
class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
{
public:
    Block(const std::span<const std::byte> raw_block)
        : Handle{btck_block_create(raw_block.data(), raw_block.size())}
    {
    }
 
    Block(btck_Block* block) : Handle{block} {}
 
    size_t CountTransactions() const
    {
        return btck_block_count_transactions(get());
    }
 
    TransactionView GetTransaction(size_t index) const
    {
        return TransactionView{btck_block_get_transaction_at(get(), index)};
    }
 
    bool Check(const ConsensusParamsView& consensus_params,
        BlockCheckFlags flags,
        BlockValidationState& state) const;
 
    MAKE_RANGE_METHOD(Transactions, Block, &Block::CountTransactions, &Block::GetTransaction, *this)
 
    BlockHash GetHash() const
    {
        return BlockHash{btck_block_get_hash(get())};
    }
 
    BlockHeader GetHeader() const
    {
        return BlockHeader{btck_block_get_header(get())};
    }
 
    std::vector<std::byte> ToBytes() const
    {
        return write_bytes(get(), btck_block_to_bytes);
    }
};
 
inline void logging_set_min_level(LogLevel level)
{
    btck_logging_set_min_level(static_cast<btck_LogLevel>(level));
}
 
class LogEntry
{
private:
    const btck_LogEntry* m_entry;
 
public:
    explicit LogEntry(const btck_LogEntry& entry) : m_entry{&entry} {}
 
    std::string_view Message() const { return {m_entry->message, m_entry->message_len}; }
    std::string_view ThreadName() const { return {m_entry->thread_name, m_entry->thread_name_len}; }
    std::chrono::sys_time<std::chrono::nanoseconds> Timestamp() const
    {
        return std::chrono::sys_time<std::chrono::nanoseconds>{std::chrono::nanoseconds{m_entry->timestamp_ns}};
    }
    std::optional<std::chrono::sys_seconds> MockTime() const
    {
        if (m_entry->mocktime_s == 0) return std::nullopt;
        return std::chrono::sys_seconds{std::chrono::seconds{m_entry->mocktime_s}};
    }
    std::string_view FileName() const { return {m_entry->file_name, m_entry->file_name_len}; }
    std::string_view FunctionName() const { return {m_entry->function_name, m_entry->function_name_len}; }
    uint32_t Line() const { return m_entry->line; }
    LogLevel Level() const { return static_cast<LogLevel>(m_entry->level); }
    LogCategory Category() const { return static_cast<LogCategory>(m_entry->category); }
};
 
template <typename T>
concept Log = requires(T a, const LogEntry& entry) {
    { a.LogMessage(entry) } -> std::same_as<void>;
};
 
template <Log T>
class Logger : UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
{
public:
    Logger(std::unique_ptr<T> log)
        : UniqueHandle{btck_logging_connection_create(
              +[](void* user_data, const btck_LogEntry* entry) { static_cast<T*>(user_data)->LogMessage(LogEntry{*entry}); },
              log.release(),
              +[](void* user_data) { delete static_cast<T*>(user_data); })}
    {
    }
};
 
class BlockTreeEntry : public View<btck_BlockTreeEntry>
{
public:
    BlockTreeEntry(const btck_BlockTreeEntry* entry)
        : View{entry}
    {
    }
 
    bool operator==(const BlockTreeEntry& other) const
    {
        return btck_block_tree_entry_equals(get(), other.get()) != 0;
    }
 
    std::optional<BlockTreeEntry> GetPrevious() const
    {
        auto entry{btck_block_tree_entry_get_previous(get())};
        if (!entry) return std::nullopt;
        return entry;
    }
 
    int32_t GetHeight() const
    {
        return btck_block_tree_entry_get_height(get());
    }
 
    BlockHashView GetHash() const
    {
        return BlockHashView{btck_block_tree_entry_get_block_hash(get())};
    }
 
    BlockHeader GetHeader() const
    {
        return BlockHeader{btck_block_tree_entry_get_block_header(get())};
    }
 
    BlockTreeEntry GetAncestor(int32_t height) const
    {
        return BlockTreeEntry{btck_block_tree_entry_get_ancestor(get(), height)};
    }
 
};
 
class KernelNotifications
{
public:
    virtual ~KernelNotifications() = default;
 
    virtual void BlockTipHandler(SynchronizationState state, BlockTreeEntry entry, double verification_progress) {}
 
    virtual void HeaderTipHandler(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {}
 
    virtual void ProgressHandler(std::string_view title, int progress_percent, bool resume_possible) {}
 
    virtual void WarningSetHandler(Warning warning, std::string_view message) {}
 
    virtual void WarningUnsetHandler(Warning warning) {}
 
    virtual void FlushErrorHandler(std::string_view error) {}
 
    virtual void FatalErrorHandler(std::string_view error) {}
};
 
template <typename Derived>
class BlockValidationStateApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    BlockValidationStateApi() = default;
 
public:
    ValidationMode GetValidationMode() const
    {
        return static_cast<ValidationMode>(btck_block_validation_state_get_validation_mode(impl()));
    }
 
    BlockValidationResult GetBlockValidationResult() const
    {
        return static_cast<BlockValidationResult>(btck_block_validation_state_get_block_validation_result(impl()));
    }
};
 
class BlockValidationStateView : public View<btck_BlockValidationState>, public BlockValidationStateApi<BlockValidationStateView>
{
public:
    explicit BlockValidationStateView(const btck_BlockValidationState* ptr) : View{ptr} {}
};
 
class BlockValidationState : public Handle<btck_BlockValidationState, btck_block_validation_state_copy, btck_block_validation_state_destroy>, public BlockValidationStateApi<BlockValidationState>
{
public:
    explicit BlockValidationState() : Handle{btck_block_validation_state_create()} {}
 
    explicit BlockValidationState(const BlockValidationStateView& view) : Handle{view} {}
 
    explicit BlockValidationState(btck_BlockValidationState* state) : Handle{state} {}
};
 
inline bool Block::Check(const ConsensusParamsView& consensus_params,
    BlockCheckFlags flags,
    BlockValidationState& state) const
{
    return btck_block_check(get(), consensus_params.get(), static_cast<btck_BlockCheckFlags>(flags), state.get()) == 1;
}
 
class TxValidationState : public UniqueHandle<btck_TxValidationState, btck_tx_validation_state_destroy>
{
public:
    using UniqueHandle::UniqueHandle; // inherit ctor
    explicit TxValidationState() : UniqueHandle{btck_tx_validation_state_create()} {}
 
    ValidationMode GetValidationMode() const
    {
        return static_cast<ValidationMode>(btck_tx_validation_state_get_validation_mode(get()));
    }
 
    TxValidationResult GetTxValidationResult() const
    {
        return static_cast<TxValidationResult>(btck_tx_validation_state_get_tx_validation_result(get()));
    }
};
 
inline bool CheckTransaction(const Transaction& tx, TxValidationState& state)
{
    return btck_transaction_check(tx.get(), state.get()) == 1;
}
 
class ValidationInterface
{
public:
    virtual ~ValidationInterface() = default;
 
    virtual void BlockChecked(Block block, BlockValidationStateView state) {}
 
    virtual void PowValidBlock(BlockTreeEntry entry, Block block) {}
 
    virtual void BlockConnected(Block block, BlockTreeEntry entry) {}
 
    virtual void BlockDisconnected(Block block, BlockTreeEntry entry) {}
};
 
class ChainParams : public Handle<btck_ChainParameters, btck_chain_parameters_copy, btck_chain_parameters_destroy>
{
public:
    explicit ChainParams(ChainType chain_type)
        : Handle{btck_chain_parameters_create(static_cast<btck_ChainType>(chain_type))} {}
 
    explicit ChainParams(std::span<const std::byte> signet_challenge)
        : Handle{btck_chain_parameters_create_signet(signet_challenge.data(), signet_challenge.size())} {}
 
    ConsensusParamsView GetConsensusParams() const
    {
        return ConsensusParamsView{btck_chain_parameters_get_consensus_params(get())};
    }
};
 
class ContextOptions : public UniqueHandle<btck_ContextOptions, btck_context_options_destroy>
{
public:
    ContextOptions() : UniqueHandle{btck_context_options_create()} {}
 
    void SetChainParams(ChainParams& chain_params)
    {
        btck_context_options_set_chainparams(get(), chain_params.get());
    }
 
    template <typename T>
    void SetNotifications(std::shared_ptr<T> notifications)
    {
        static_assert(std::is_base_of_v<KernelNotifications, T>);
        auto heap_notifications = std::make_unique<std::shared_ptr<T>>(std::move(notifications));
        using user_type = std::shared_ptr<T>*;
        btck_context_options_set_notifications(
            get(),
            btck_NotificationInterfaceCallbacks{
                .user_data = heap_notifications.release(),
                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
                .block_tip = +[](void* user_data, btck_SynchronizationState state, const btck_BlockTreeEntry* entry, double verification_progress) { (*static_cast<user_type>(user_data))->BlockTipHandler(static_cast<SynchronizationState>(state), BlockTreeEntry{entry}, verification_progress); },
                .header_tip = +[](void* user_data, btck_SynchronizationState state, int64_t height, int64_t timestamp, int presync) { (*static_cast<user_type>(user_data))->HeaderTipHandler(static_cast<SynchronizationState>(state), height, timestamp, presync == 1); },
                .progress = +[](void* user_data, const char* title, size_t title_len, int progress_percent, int resume_possible) { (*static_cast<user_type>(user_data))->ProgressHandler({title, title_len}, progress_percent, resume_possible == 1); },
                .warning_set = +[](void* user_data, btck_Warning warning, const char* message, size_t message_len) { (*static_cast<user_type>(user_data))->WarningSetHandler(static_cast<Warning>(warning), {message, message_len}); },
                .warning_unset = +[](void* user_data, btck_Warning warning) { (*static_cast<user_type>(user_data))->WarningUnsetHandler(static_cast<Warning>(warning)); },
                .flush_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FlushErrorHandler({error, error_len}); },
                .fatal_error = +[](void* user_data, const char* error, size_t error_len) { (*static_cast<user_type>(user_data))->FatalErrorHandler({error, error_len}); },
            });
    }
 
    template <typename T>
    void SetValidationInterface(std::shared_ptr<T> validation_interface)
    {
        static_assert(std::is_base_of_v<ValidationInterface, T>);
        auto heap_vi = std::make_unique<std::shared_ptr<T>>(std::move(validation_interface));
        using user_type = std::shared_ptr<T>*;
        btck_context_options_set_validation_interface(
            get(),
            btck_ValidationInterfaceCallbacks{
                .user_data = heap_vi.release(),
                .user_data_destroy = +[](void* user_data) { delete static_cast<user_type>(user_data); },
                .block_checked = +[](void* user_data, btck_Block* block, const btck_BlockValidationState* state) { (*static_cast<user_type>(user_data))->BlockChecked(Block{block}, BlockValidationStateView{state}); },
                .pow_valid_block = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->PowValidBlock(BlockTreeEntry{entry}, Block{block}); },
                .block_connected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockConnected(Block{block}, BlockTreeEntry{entry}); },
                .block_disconnected = +[](void* user_data, btck_Block* block, const btck_BlockTreeEntry* entry) { (*static_cast<user_type>(user_data))->BlockDisconnected(Block{block}, BlockTreeEntry{entry}); },
            });
    }
};
 
class Context : public Handle<btck_Context, btck_context_copy, btck_context_destroy>
{
public:
    Context(ContextOptions& opts)
        : Handle{btck_context_create(opts.get())} {}
 
    Context()
        : Handle{btck_context_create(ContextOptions{}.get())} {}
 
    bool interrupt()
    {
        return btck_context_interrupt(get()) == 0;
    }
};
 
class ChainstateManagerOptions : public UniqueHandle<btck_ChainstateManagerOptions, btck_chainstate_manager_options_destroy>
{
public:
    ChainstateManagerOptions(const Context& context, std::string_view data_dir, std::string_view blocks_dir)
        : UniqueHandle{btck_chainstate_manager_options_create(
              context.get(), data_dir.data(), data_dir.length(), blocks_dir.data(), blocks_dir.length())}
    {
    }
 
    void SetWorkerThreads(int worker_threads)
    {
        btck_chainstate_manager_options_set_worker_threads_num(get(), worker_threads);
    }
 
    bool SetDatabaseCacheBytes(uint64_t database_cache_bytes)
    {
        return btck_chainstate_manager_options_set_database_cache_bytes(get(), database_cache_bytes) == 0;
    }
 
    bool SetWipeDbs(bool wipe_block_tree, bool wipe_chainstate)
    {
        return btck_chainstate_manager_options_set_wipe_dbs(get(), wipe_block_tree, wipe_chainstate) == 0;
    }
 
    void UpdateBlockTreeDbInMemory(bool block_tree_db_in_memory)
    {
        btck_chainstate_manager_options_update_block_tree_db_in_memory(get(), block_tree_db_in_memory);
    }
 
    void UpdateChainstateDbInMemory(bool chainstate_db_in_memory)
    {
        btck_chainstate_manager_options_update_chainstate_db_in_memory(get(), chainstate_db_in_memory);
    }
};
 
class ChainView : public View<btck_Chain>
{
public:
    explicit ChainView(const btck_Chain* ptr) : View{ptr} {}
 
    int32_t Height() const
    {
        return btck_chain_get_height(get());
    }
 
    int32_t CountEntries() const
    {
        return btck_chain_get_height(get()) + 1;
    }
 
    BlockTreeEntry GetByHeight(int32_t height) const
    {
        auto index{btck_chain_get_by_height(get(), height)};
        if (!index) throw std::runtime_error("No entry in the chain at the provided height");
        return index;
    }
 
    bool Contains(BlockTreeEntry& entry) const
    {
        return btck_chain_contains(get(), entry.get());
    }
 
    MAKE_RANGE_METHOD(Entries, ChainView, &ChainView::CountEntries, &ChainView::GetByHeight, *this)
};
 
template <typename Derived>
class CoinApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    CoinApi() = default;
 
public:
    uint32_t GetConfirmationHeight() const { return btck_coin_confirmation_height(impl()); }
 
    bool IsCoinbase() const { return btck_coin_is_coinbase(impl()) == 1; }
 
    TransactionOutputView GetOutput() const
    {
        return TransactionOutputView{btck_coin_get_output(impl())};
    }
};
 
class CoinView : public View<btck_Coin>, public CoinApi<CoinView>
{
public:
    explicit CoinView(const btck_Coin* ptr) : View{ptr} {}
};
 
class Coin : public Handle<btck_Coin, btck_coin_copy, btck_coin_destroy>, public CoinApi<Coin>
{
public:
    Coin(btck_Coin* coin) : Handle{coin} {}
 
    Coin(const CoinView& view) : Handle{view} {}
};
 
template <typename Derived>
class TransactionSpentOutputsApi
{
private:
    auto impl() const
    {
        return static_cast<const Derived*>(this)->get();
    }
 
    friend Derived;
    TransactionSpentOutputsApi() = default;
 
public:
    size_t Count() const
    {
        return btck_transaction_spent_outputs_count(impl());
    }
 
    CoinView GetCoin(size_t index) const
    {
        return CoinView{btck_transaction_spent_outputs_get_coin_at(impl(), index)};
    }
 
    MAKE_RANGE_METHOD(Coins, Derived, &TransactionSpentOutputsApi<Derived>::Count, &TransactionSpentOutputsApi<Derived>::GetCoin, *static_cast<const Derived*>(this))
};
 
class TransactionSpentOutputsView : public View<btck_TransactionSpentOutputs>, public TransactionSpentOutputsApi<TransactionSpentOutputsView>
{
public:
    explicit TransactionSpentOutputsView(const btck_TransactionSpentOutputs* ptr) : View{ptr} {}
};
 
class TransactionSpentOutputs : public Handle<btck_TransactionSpentOutputs, btck_transaction_spent_outputs_copy, btck_transaction_spent_outputs_destroy>,
                                public TransactionSpentOutputsApi<TransactionSpentOutputs>
{
public:
    TransactionSpentOutputs(btck_TransactionSpentOutputs* transaction_spent_outputs) : Handle{transaction_spent_outputs} {}
 
    TransactionSpentOutputs(const TransactionSpentOutputsView& view) : Handle{view} {}
};
 
class BlockSpentOutputs : public Handle<btck_BlockSpentOutputs, btck_block_spent_outputs_copy, btck_block_spent_outputs_destroy>
{
public:
    BlockSpentOutputs(btck_BlockSpentOutputs* block_spent_outputs)
        : Handle{block_spent_outputs}
    {
    }
 
    size_t Count() const
    {
        return btck_block_spent_outputs_count(get());
    }
 
    TransactionSpentOutputsView GetTxSpentOutputs(size_t tx_undo_index) const
    {
        return TransactionSpentOutputsView{btck_block_spent_outputs_get_transaction_spent_outputs_at(get(), tx_undo_index)};
    }
 
    MAKE_RANGE_METHOD(TxsSpentOutputs, BlockSpentOutputs, &BlockSpentOutputs::Count, &BlockSpentOutputs::GetTxSpentOutputs, *this)
};
 
class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_destroy>
{
public:
    ChainMan(const Context& context, const ChainstateManagerOptions& chainman_opts)
        : UniqueHandle{btck_chainstate_manager_create(chainman_opts.get())}
    {
    }
 
    bool ImportBlocks(const std::span<const std::string> paths)
    {
        std::vector<const char*> c_paths;
        std::vector<size_t> c_paths_lens;
        c_paths.reserve(paths.size());
        c_paths_lens.reserve(paths.size());
        for (const auto& path : paths) {
            c_paths.push_back(path.c_str());
            c_paths_lens.push_back(path.length());
        }
 
        return btck_chainstate_manager_import_blocks(get(), c_paths.data(), c_paths_lens.data(), c_paths.size()) == 0;
    }
 
    bool ProcessBlock(const Block& block, bool* new_block)
    {
        int _new_block;
        int res = btck_chainstate_manager_process_block(get(), block.get(), &_new_block);
        if (new_block) *new_block = _new_block == 1;
        return res == 0;
    }
 
    BlockValidationState ProcessBlockHeader(const BlockHeader& header)
    {
        auto state = btck_chainstate_manager_process_block_header(get(), header.get());
        return BlockValidationState{state};
    }
 
    ChainView GetChain() const
    {
        return ChainView{btck_chainstate_manager_get_active_chain(get())};
    }
 
    std::optional<BlockTreeEntry> GetBlockTreeEntry(const BlockHash& block_hash) const
    {
        auto entry{btck_chainstate_manager_get_block_tree_entry_by_hash(get(), block_hash.get())};
        if (!entry) return std::nullopt;
        return entry;
    }
 
    BlockTreeEntry GetBestEntry() const
    {
        return btck_chainstate_manager_get_best_entry(get());
    }
 
    std::optional<Block> ReadBlock(const BlockTreeEntry& entry) const
    {
        auto block{btck_block_read(get(), entry.get())};
        if (!block) return std::nullopt;
        return block;
    }
 
    BlockSpentOutputs ReadBlockSpentOutputs(const BlockTreeEntry& entry) const
    {
        return btck_block_spent_outputs_read(get(), entry.get());
    }
};
 
inline void set_mock_time(std::chrono::seconds timestamp)
{
    if (btck_set_mock_time(timestamp.count()) != 0) {
        throw std::runtime_error("timestamp out of range");
    }
}
 
} // namespace btck
 
#endif // BITCOIN_KERNEL_BITCOINKERNEL_WRAPPER_H