From badc3a5f86b76a33a8f4ef809dc22df03bfad2e1 Mon Sep 17 00:00:00 2001
From: TheCharlatan <seb.kung@gmail.com>
Date: Wed, 1 Feb 2023 17:04:26 +0100
Subject: [PATCH] Kernel: Implement PoC FFI

---
 .gitignore                         |   2 +
 Makefile.am                        |   1 +
 configure.ac                       |   4 +
 libbitcoinkernel.pc.in             |  10 +
 src/Makefile.am                    |  14 +-
 src/bitcoin-chainstate-wrapper.cpp | 520 +++++++++++++++++++++++++++++
 src/bitcoin-chainstate.c           | 112 +++++++
 src/bitcoinkernel.h                | 106 ++++++
 src/validation.h                   |   2 +
 9 files changed, 770 insertions(+), 1 deletion(-)
 create mode 100644 libbitcoinkernel.pc.in
 create mode 100644 src/bitcoin-chainstate-wrapper.cpp
 create mode 100644 src/bitcoin-chainstate.c
 create mode 100644 src/bitcoinkernel.h

diff --git a/.gitignore b/.gitignore
index c77303f50e2ee9..a8062d755f9dca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ src/bitcoin-node
 src/bitcoin-tx
 src/bitcoin-util
 src/bitcoin-chainstate
+src/bitcoin-chainstate_c
 src/bitcoin-wallet
 src/test/fuzz/fuzz
 src/test/test_bitcoin
@@ -136,6 +137,7 @@ test/.mypy_cache/
 /doc/doxygen/
 
 libbitcoinconsensus.pc
+libbitcoinkernel.pc
 contrib/devtools/split-debug.sh
 
 # Output from running db4 installation
diff --git a/Makefile.am b/Makefile.am
index c50421dfc339ea..09588422ccbfcb 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -17,6 +17,7 @@ endif
 if BUILD_BITCOIN_LIBS
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libbitcoinconsensus.pc
+pkgconfig_DATA += libbitcoinkernel.pc
 endif
 
 BITCOIND_BIN=$(top_builddir)/src/$(BITCOIN_DAEMON_NAME)$(EXEEXT)
diff --git a/configure.ac b/configure.ac
index 1b5dc32b046be4..1a6154c5ca268a 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1680,6 +1680,10 @@ fi
 
 AM_CONDITIONAL([BUILD_BITCOIN_KERNEL_LIB], [test "$build_experimental_kernel_lib" != "no" && ( test "$build_experimental_kernel_lib" = "yes" || test "$build_bitcoin_chainstate" = "yes" )])
 
+if test "$build_bitcoin_kernel_lib" = "yes"; then
+  AC_CONFIG_FILES([libbitcoinkernel.pc:libbitcoinkernel.pc.in])
+fi
+
 AC_MSG_RESULT($build_bitcoin_libs)
 
 AC_LANG_POP
diff --git a/libbitcoinkernel.pc.in b/libbitcoinkernel.pc.in
new file mode 100644
index 00000000000000..13e0dd5df9fc3e
--- /dev/null
+++ b/libbitcoinkernel.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@ kernel library
+Description: Library for the Bitcoin chain validation.
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lbitcoinkernel
+Cflags: -I${includedir}
diff --git a/src/Makefile.am b/src/Makefile.am
index be2bb0f318bc4e..cef3a6ea48b9d3 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -15,6 +15,7 @@ AM_LIBTOOLFLAGS = --preserve-dup-deps
 PTHREAD_FLAGS = $(PTHREAD_CFLAGS) $(PTHREAD_LIBS)
 EXTRA_LIBRARIES =
 
+include_HEADERS =
 lib_LTLIBRARIES =
 noinst_LTLIBRARIES =
 
@@ -112,6 +113,7 @@ endif
 
 if BUILD_BITCOIN_CHAINSTATE
   bin_PROGRAMS += bitcoin-chainstate
+  bin_PROGRAMS += bitcoin-chainstate_c
 endif
 
 .PHONY: FORCE check-symbols check-security
@@ -126,6 +128,7 @@ BITCOIN_CORE_H = \
   base58.h \
   bech32.h \
   bip324.h \
+  bitcoinkernel.h \
   blockencodings.h \
   blockfilter.h \
   chain.h \
@@ -892,6 +895,13 @@ bitcoin_util_LDADD = \
   $(LIBSECP256K1)
 #
 
+# bitcoin-chainstate C binary #
+bitcoin_chainstate_c_SOURCES = bitcoin-chainstate.c
+bitcoin_chainstate_c_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BOOST_CPPFLAGS)
+bitcoin_chainstate_c_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+bitcoin_chainstate_c_LDFLAGS = $(RELDFLAGS) $(LIBTOOL_APP_LDFLAGS) $(AM_LDFLAGS) $(PTHREAD_FLAGS)
+bitcoin_chainstate_c_LDADD = $(LIBBITCOINKERNEL)
+
 # bitcoin-chainstate binary #
 bitcoin_chainstate_SOURCES = bitcoin-chainstate.cpp
 bitcoin_chainstate_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BOOST_CPPFLAGS)
@@ -908,6 +918,7 @@ bitcoin_chainstate_LDADD += $(LIBSECP256K1)
 # bitcoinkernel library #
 if BUILD_BITCOIN_KERNEL_LIB
 lib_LTLIBRARIES += $(LIBBITCOINKERNEL)
+include_HEADERS += bitcoinkernel.h
 
 libbitcoinkernel_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS) $(PTHREAD_FLAGS)
 libbitcoinkernel_la_LIBADD = $(LIBBITCOIN_CRYPTO) $(LIBLEVELDB) $(LIBMEMENV) $(LIBSECP256K1)
@@ -949,6 +960,7 @@ libbitcoinkernel_la_SOURCES = \
   kernel/disconnected_transactions.cpp \
   kernel/mempool_persist.cpp \
   kernel/mempool_removal_reason.cpp \
+  bitcoin-chainstate-wrapper.cpp \
   key.cpp \
   logging.cpp \
   node/blockstorage.cpp \
@@ -1011,7 +1023,7 @@ endif # BUILD_BITCOIN_KERNEL_LIB
 if BUILD_BITCOIN_LIBS
 lib_LTLIBRARIES += $(LIBBITCOINCONSENSUS)
 
-include_HEADERS = script/bitcoinconsensus.h
+include_HEADERS += script/bitcoinconsensus.h
 libbitcoinconsensus_la_SOURCES = support/cleanse.cpp $(crypto_libbitcoin_crypto_base_la_SOURCES) $(libbitcoin_consensus_a_SOURCES)
 
 libbitcoinconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS)
diff --git a/src/bitcoin-chainstate-wrapper.cpp b/src/bitcoin-chainstate-wrapper.cpp
new file mode 100644
index 00000000000000..bddcfb92e37749
--- /dev/null
+++ b/src/bitcoin-chainstate-wrapper.cpp
@@ -0,0 +1,520 @@
+#include <kernel/checks.h>
+#include <kernel/context.h>
+#include <kernel/validation_cache_sizes.h>
+
+#include <chainparams.h>
+#include <consensus/validation.h>
+#include <core_io.h>
+#include <logging.h>
+#include <node/blockstorage.h>
+#include <node/caches.h>
+#include <node/chainstate.h>
+#include <script/sigcache.h>
+#include <util/thread.h>
+#include <validation.h>
+#include <validationinterface.h>
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <filesystem>
+#include <functional>
+#include <iosfwd>
+#include <iostream>
+#include <memory>
+#include <thread>
+
+#include <bitcoinkernel.h>
+
+static LogCallback g_log_callback = nullptr;
+
+void log_info(const char* msg)
+{
+    if (g_log_callback) {
+        g_log_callback(msg);
+    } else {
+        std::cout << msg << std::endl;
+    }
+}
+
+void log_error(const char* msg)
+{
+    if (g_log_callback) {
+        g_log_callback(strprintf("Error: %s\n", msg).c_str());
+    } else {
+        std::cerr << msg << std::endl;
+    }
+}
+
+const char* fmt_bool(bool b)
+{
+    return b ? "true" : "false";
+}
+
+C_SynchronizationState cast_state(SynchronizationState state) {
+    switch (state)
+    {
+    case SynchronizationState::INIT_REINDEX:
+        return C_SynchronizationState::INIT_REINDEX;
+    case SynchronizationState::INIT_DOWNLOAD:
+        return C_SynchronizationState::INIT_DOWNLOAD;
+    case SynchronizationState::POST_INIT:
+        return C_SynchronizationState::POST_INIT;
+    }
+    assert(false);
+}
+
+class KernelNotifications : public kernel::Notifications
+{
+private:
+    KernelNotificationInterfaceCallbacks m_cbs;
+
+public:
+    explicit KernelNotifications(
+        KernelNotificationInterfaceCallbacks kn_cbs
+    ) : m_cbs{kn_cbs} {}
+
+    kernel::InterruptResult blockTip(SynchronizationState state, CBlockIndex& index) override
+    {
+        log_info("Block tip changed.");
+        if (m_cbs.block_tip) m_cbs.block_tip(m_cbs.user_data, cast_state(state), nullptr);
+        return {};
+    }
+    void headerTip(SynchronizationState state, int64_t height, int64_t timestamp, bool presync) override
+    {
+        log_info(strprintf("Header tip changed: %d, %d, %d", height, timestamp, presync).c_str());
+        if (m_cbs.header_tip) m_cbs.header_tip(m_cbs.user_data, cast_state(state), height, timestamp, presync);
+    }
+    void progress(const bilingual_str& title, int progress_percent, bool resume_possible) override
+    {
+        log_info(strprintf("Progress: %s, %d, %d\n", title.original, progress_percent, resume_possible).c_str());
+        if (m_cbs.progress) m_cbs.progress(m_cbs.user_data, title.original.c_str(), progress_percent, resume_possible);
+    }
+    void warning(const bilingual_str& warning) override
+    {
+        log_info(strprintf("Warning: %s", warning.original).c_str());
+        if (m_cbs.warning) m_cbs.warning(m_cbs.user_data, warning.original.c_str());
+    }
+    void flushError(const std::string& debug_message) override
+    {
+        log_error(strprintf("Error flushing block data to disk: %s", debug_message).c_str());
+        if (m_cbs.flush_error) m_cbs.flush_error(m_cbs.user_data, debug_message.c_str());
+    }
+    void fatalError(const std::string& debug_message, const bilingual_str& user_message) override
+    {
+        log_error(debug_message.c_str());
+        log_error((user_message.empty() ? "A fatal internal error occurred." : user_message.original).c_str());
+        if (m_cbs.fatal_error) m_cbs.fatal_error(m_cbs.user_data, debug_message.c_str(), user_message.original.c_str());
+    }
+};
+
+void c_execute_event(void* event) {
+    std::function<void()>* func = static_cast<std::function<void()>*>(event);
+    (*func)();
+    delete func;
+}
+
+class DummyQueue : public ValidationInterfaceQueue
+{
+private:
+    ValidationInterfaceQueueCallbacks m_cbs;
+
+public:
+    DummyQueue(ValidationInterfaceQueueCallbacks viq_cbs) : m_cbs{viq_cbs} {}
+
+    void AddToProcessQueue(std::function<void()> func) override
+    {
+        // prevent the event from being deleted when it goes out of scope
+        // here, it is the caller's responsibility to correctly call
+        // c_execute_event to process it, preventing a memory leak.
+        auto heap_func = new std::function<void()>(func);
+
+        if (m_cbs.add_to_process_queue) m_cbs.add_to_process_queue(m_cbs.user_data, heap_func);
+    }
+
+    void EmptyQueue() override
+    {
+        if (m_cbs.empty_queue) m_cbs.empty_queue(m_cbs.user_data);
+    }
+
+    size_t CallbacksPending() override
+    {
+        if (m_cbs.callbacks_pending) return m_cbs.callbacks_pending(m_cbs.user_data);
+        return 0;
+    }
+};
+
+class ContextWrapper
+{
+public:
+
+    std::unique_ptr<kernel::Context> m_context;
+
+    std::unique_ptr<CMainSignals> m_signals;
+
+    std::unique_ptr<kernel::Notifications> m_notifications;
+
+    std::unique_ptr<const CChainParams> m_chainparams = CChainParams::SigNet({});
+
+    ContextWrapper(
+            KernelNotificationInterfaceCallbacks kn_cbs,
+            ValidationInterfaceQueueCallbacks viq_cbs
+    ) {
+        m_signals = std::make_unique<CMainSignals>(std::make_unique<DummyQueue>(viq_cbs));
+        m_notifications = std::make_unique<KernelNotifications>(kn_cbs);
+        m_context = std::make_unique<kernel::Context>();
+
+        // As long as we don't have error infrastructure here, this remains an assert.
+        assert(kernel::SanityChecks(*m_context));
+
+        // Necessary for CheckInputScripts (eventually called by ProcessNewBlock),
+        // which will try the script cache first and fall back to actually
+        // performing the check with the signature cache.
+        kernel::ValidationCacheSizes validation_cache_sizes{};
+        assert(InitSignatureCache(validation_cache_sizes.signature_cache_bytes));
+        assert(InitScriptExecutionCache(validation_cache_sizes.script_execution_cache_bytes));
+    }
+
+    bool healthy() {
+        return true;
+    }
+};
+
+static ContextWrapper* cast_context_wrapper(void* context_wrapper)
+{
+    if (!context_wrapper || !(static_cast<ContextWrapper *>(context_wrapper))->healthy() ) {
+        log_error("Received invalid context pointer\n");
+    }
+    return static_cast<ContextWrapper*>(context_wrapper);
+}
+
+void* c_context_new(KernelNotificationInterfaceCallbacks kn_cbs, ValidationInterfaceQueueCallbacks viq_cbs)
+{
+    return new ContextWrapper(kn_cbs, viq_cbs);
+}
+
+void c_context_delete(void* context) {
+    auto context_wrapper = cast_context_wrapper(context);
+    context_wrapper->m_signals->UnregisterAllValidationInterfaces();
+    delete context_wrapper;
+}
+
+void c_set_logging_callback_and_start_logging(LogCallback callback) {
+    g_log_callback = callback;
+    LogInstance().m_print_to_file = false;
+    LogInstance().m_print_to_console = false;
+    LogInstance().m_log_timestamps = false;
+    LogInstance().PushBackCallback([](const std::string& str) { g_log_callback(str.c_str()); });
+    if (!LogInstance().StartLogging()) {
+        log_error("Logger start failed.\n");
+    } else {
+        log_info("Logger started.");
+    }
+}
+
+void* c_chainstate_manager_create(const char* data_dir, void* context_wrapper_) {
+    auto context_wrapper = cast_context_wrapper(context_wrapper_);
+
+    // SETUP: Argument parsing and handling
+    fs::path abs_datadir{fs::absolute(fs::PathFromString(data_dir))};
+    fs::create_directories(abs_datadir);
+
+    // SETUP: Chainstate
+    const ChainstateManager::Options chainman_opts{
+        .chainparams = *context_wrapper->m_chainparams,
+        .datadir = abs_datadir,
+        .adjusted_time_callback = NodeClock::now,
+        .notifications = *context_wrapper->m_notifications,
+    };
+    const node::BlockManager::Options blockman_opts{
+        .chainparams = chainman_opts.chainparams,
+        .blocks_dir = abs_datadir / "blocks",
+        .notifications = chainman_opts.notifications,
+    };
+    ChainstateManager* chainman = new ChainstateManager{context_wrapper->m_context->interrupt, chainman_opts, blockman_opts, *context_wrapper->m_signals};
+
+    node::CacheSizes cache_sizes;
+    cache_sizes.block_tree_db = 2 << 20;
+    cache_sizes.coins_db = 2 << 22;
+    cache_sizes.coins = (450 << 20) - (2 << 20) - (2 << 22);
+    node::ChainstateLoadOptions options;
+    options.check_interrupt = [] { return false; };
+    auto [status, error] = node::LoadChainstate(*chainman, cache_sizes, options);
+    if (status != node::ChainstateLoadStatus::SUCCESS) {
+        log_error("Failed to load Chain state from your datadir.");
+        c_chainstate_manager_delete(chainman, context_wrapper_);
+        return nullptr;
+    } else {
+        std::tie(status, error) = node::VerifyLoadedChainstate(*chainman, options);
+        if (status != node::ChainstateLoadStatus::SUCCESS) {
+            log_error("Failed to verify loaded Chain state from your datadir.");
+            c_chainstate_manager_delete(chainman, context_wrapper_);
+            return nullptr;
+        }
+    }
+
+    for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman->GetAll())) {
+        BlockValidationState state;
+        if (!chainstate->ActivateBestChain(state, nullptr)) {
+            log_error(strprintf("Failed to connect best block (%s)", state.ToString()).c_str());
+            c_chainstate_manager_delete(chainman, context_wrapper_);
+            return nullptr;
+        }
+    }
+
+    C_ChainstateInfo info = c_get_chainstate_info(chainman);
+
+    {
+        LOCK(chainman->GetMutex());
+        auto msg = strprintf(
+            "Successfully loaded chainstate:\n\tData Directory: %s\n\tReindexing: %s\n\tSnapshot Active: %s\n\tActive Height: %s\n\tActive IBD: %s",
+            info.path,
+            fmt_bool(info.reindexing),
+            fmt_bool(info.snapshot_active),
+            info.active_height,
+            fmt_bool(info.active_ibd));
+        CBlockIndex* tip = chainman->ActiveTip();
+        if (tip) {
+            log_info(strprintf("%s\n\tActive Tip: %s", msg, tip->ToString()).c_str());
+        } else {
+            log_info(msg.c_str());
+        }
+    }
+    return chainman;
+}
+
+void* c_chainstate_coins_cursor(void* chainman_) {
+    if (!chainman_ || !(static_cast<ChainstateManager *>(chainman_))->healthy() ) {
+        log_error("Received invalid chainman pointer");
+    }
+    ChainstateManager* chainman = static_cast<ChainstateManager*>(chainman_);
+
+    auto cursor = WITH_LOCK(::cs_main, return chainman->ActiveChainstate().CoinsDB()).Cursor();
+    return cursor.release();
+}
+
+void c_coins_cursor_next(void* cursor_) {
+    if (!cursor_ || !(static_cast<CCoinsViewCursor *>(cursor_))->Valid()) {
+        log_error("Received invalid cursor pointer");
+    }
+    CCoinsViewCursor* cursor = static_cast<CCoinsViewCursor*>(cursor_);
+    cursor->Next();
+}
+
+C_OutPoint c_coins_cursor_get_key(void* cursor_) {
+    if (!cursor_ || !(static_cast<CCoinsViewCursor *>(cursor_))->Valid()) {
+        log_error("Received invalid cursor pointer");
+    }
+    CCoinsViewCursor* cursor = static_cast<CCoinsViewCursor*>(cursor_);
+    COutPoint key;
+    cursor->GetKey(key);
+
+    C_OutPoint out_point{
+        .hash = {},
+        .n = key.n,
+    };
+    std::memcpy(out_point.hash, key.hash.data(), sizeof(out_point.hash));
+    return out_point;
+}
+
+int c_coins_cursor_valid(void* cursor_) {
+    if (!cursor_ || !(static_cast<CCoinsViewCursor *>(cursor_))->Valid()) {
+        return false;
+    }
+    return true;
+}
+
+void c_coins_cursor_delete(void* cursor_) {
+    if (!cursor_) {
+        log_error("Received invalid cursor pointer");
+    }
+    CCoinsViewCursor* cursor = static_cast<CCoinsViewCursor*>(cursor_);
+    delete cursor;
+}
+
+std::string CScriptToHexString(const CScript& script) {
+    std::ostringstream ss;
+    ss << std::hex;
+    for (const auto& byte : script) {
+        ss << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
+    }
+    return ss.str();
+}
+
+C_Coin c_coins_cursor_get_value(void* cursor_) {
+    if (!cursor_ || !(static_cast<CCoinsViewCursor *>(cursor_))->Valid()) {
+        log_error("Received invalid cursor pointer");
+    }
+    CCoinsViewCursor* cursor = static_cast<CCoinsViewCursor*>(cursor_);
+    Coin coin;
+    cursor->GetValue(coin);
+
+    std::vector<uint8_t> temp(coin.out.scriptPubKey.begin(), coin.out.scriptPubKey.end());
+    C_Coin c_coin{
+        .out = C_TxOut{
+            .value = coin.out.nValue,
+            .script_pubkey = ByteArray {
+                .data = coin.out.scriptPubKey.data(),
+                .len = coin.out.scriptPubKey.size(),
+            },
+        },
+        .is_coinbase = coin.fCoinBase,
+        .confirmation_height = coin.nHeight,
+    };
+    return c_coin;
+}
+
+C_ChainstateInfo c_get_chainstate_info(void* chainman_) {
+    if (!chainman_ || !(static_cast<ChainstateManager *>(chainman_))->healthy() ) {
+        log_error("Received invalid chainman pointer");
+    }
+
+    ChainstateManager* chainman = static_cast<ChainstateManager*>(chainman_);
+    C_ChainstateInfo info{
+        .path = chainman->m_options.datadir.c_str(),
+        .reindexing = node::fReindex.load(),
+        .snapshot_active = chainman->IsSnapshotActive(),
+        .active_height = WITH_LOCK(::cs_main, return chainman->ActiveHeight()),
+        .active_ibd = chainman->IsInitialBlockDownload(),
+    };
+    return info;
+}
+
+class ValidateBlockValidationInterface final : public CValidationInterface
+{
+public:
+    BlockValidationState m_state;
+
+
+    explicit ValidateBlockValidationInterface(const uint256& hashIn) : m_state{} {}
+protected:
+    void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override
+    {
+        m_state = stateIn;
+    }
+};
+
+int c_chainstate_manager_validate_block(void* chainman_, void* context_, const char* raw_c_block)
+{
+    if (!chainman_ || !(static_cast<ChainstateManager *>(chainman_))->healthy() ) {
+        log_error("Received invalid chainman pointer");
+        return -1;
+    }
+    ChainstateManager* chainman = static_cast<ChainstateManager*>(chainman_);
+    auto context_wrapper = cast_context_wrapper(context_);
+    std::string raw_block(raw_c_block);
+    if (raw_block.empty()) {
+        log_error("Empty line found");
+        return 1;
+    }
+
+    std::shared_ptr<CBlock> blockptr = std::make_shared<CBlock>();
+    CBlock& block = *blockptr;
+
+    if (!DecodeHexBlk(block, raw_block)) {
+        log_error("Block decode failed");
+        return 1;
+    }
+
+    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase()) {
+        log_error("Block does not start with a coinbase");
+        return 1;
+    }
+
+    uint256 hash = block.GetHash();
+    {
+        LOCK(cs_main);
+        const CBlockIndex* pindex = chainman->m_blockman.LookupBlockIndex(hash);
+        if (pindex) {
+            if (pindex->IsValid(BLOCK_VALID_SCRIPTS)) {
+                log_error("duplicate");
+                return 1;
+            }
+            if (pindex->nStatus & BLOCK_FAILED_MASK) {
+                log_error("duplicate-invalid");
+                return 1;
+            }
+        }
+    }
+
+    {
+        LOCK(cs_main);
+        const CBlockIndex* pindex = chainman->m_blockman.LookupBlockIndex(block.hashPrevBlock);
+        if (pindex) {
+            chainman->UpdateUncommittedBlockStructures(block, pindex);
+        }
+    }
+
+    bool new_block;
+    auto sc = std::make_shared<ValidateBlockValidationInterface>(block.GetHash());
+    context_wrapper->m_signals->RegisterSharedValidationInterface(sc);
+    bool accepted = chainman->ProcessNewBlock(blockptr, /*force_processing=*/true, /*min_pow_checked=*/true, /*new_block=*/&new_block);
+    context_wrapper->m_signals->UnregisterSharedValidationInterface(sc);
+    if (!new_block && accepted) {
+        log_error("duplicate");
+        return 1;
+    }
+    log_info(sc->m_state.ToString().c_str());
+    switch (sc->m_state.GetResult()) {
+    case BlockValidationResult::BLOCK_RESULT_UNSET:
+        log_info("Block passed ProcessNewBlock");
+        return 0;
+    case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
+        log_error("the block header may be on a too-little-work chain");
+        return 1;
+    case BlockValidationResult::BLOCK_CONSENSUS:
+        log_error("invalid by consensus rules (excluding any below reasons)");
+        return 1;
+    case BlockValidationResult::BLOCK_RECENT_CONSENSUS_CHANGE:
+        log_error("Invalid by a change to consensus rules more recent than SegWit.");
+        return 1;
+    case BlockValidationResult::BLOCK_CACHED_INVALID:
+        log_error("this block was cached as being invalid and we didn't store the reason why");
+        return 1;
+    case BlockValidationResult::BLOCK_INVALID_HEADER:
+        log_error("invalid proof of work or time too old");
+        return 1;
+    case BlockValidationResult::BLOCK_MUTATED:
+        log_error("the block's data didn't match the data committed to by the PoW");
+        return 1;
+    case BlockValidationResult::BLOCK_MISSING_PREV:
+        log_error("We don't have the previous block the checked one is built on");
+        return 1;
+    case BlockValidationResult::BLOCK_INVALID_PREV:
+        log_error("A block this one builds on is invalid");
+        return 1;
+    case BlockValidationResult::BLOCK_TIME_FUTURE:
+        log_error("block timestamp was > 2 hours in the future (or our clock is bad)");
+        return 1;
+    case BlockValidationResult::BLOCK_CHECKPOINT:
+        log_error("the block failed to meet one of our checkpoints");
+        return 1;
+    }
+    return 0;
+}
+
+int c_chainstate_manager_delete(void* chainman_, void* context_wrapper_) {
+    if (!chainman_ || !(static_cast<ChainstateManager *>(chainman_))->healthy() ) {
+        log_error("Received invalid chainman pointer");
+        return -1;
+    }
+    ChainstateManager* chainman = static_cast<ChainstateManager*>(chainman_);
+    auto context_wrapper = cast_context_wrapper(context_wrapper_);
+
+    chainman->ActiveChainstate().ForceFlushStateToDisk();
+    // Without this precise shutdown sequence, there will be a lot of nullptr
+    // dereferencing and UB.
+    context_wrapper->m_signals->FlushBackgroundCallbacks();
+    {
+        LOCK(cs_main);
+        for (Chainstate* chainstate : chainman->GetAll()) {
+            if (chainstate->CanFlushToDisk()) {
+                chainstate->ForceFlushStateToDisk();
+                chainstate->ResetCoinsViews();
+            }
+        }
+    }
+    delete chainman;
+
+    return 0;
+}
diff --git a/src/bitcoin-chainstate.c b/src/bitcoin-chainstate.c
new file mode 100644
index 00000000000000..95a05d61a80786
--- /dev/null
+++ b/src/bitcoin-chainstate.c
@@ -0,0 +1,112 @@
+#include "stdio.h"
+#include "stddef.h"
+#include "stdint.h"
+#include "stdbool.h"
+#include "unistd.h"
+#include "bitcoinkernel.h"
+
+void log_printf(const char* message) {
+    printf("kernel: %s", message);
+}
+
+void KNBlockTipCB(void* _, enum C_SynchronizationState state, void* _index) {
+    log_printf("Block tip changed\n");
+}
+
+void KNHeaderTipCB(void* _, enum C_SynchronizationState state, int64_t height, int64_t timestamp, bool presync) {
+    char buffer[100];
+    snprintf(buffer, 100, "Received new header: %ld, %ld. Ready for presync: %d\n", height, timestamp, presync);
+    log_printf(buffer);
+}
+
+void KNProgressCB(void* _, const char* title, int progress_percent, bool resume_possible) {
+    char buffer[200];
+    if (title == NULL) {
+        snprintf(buffer, 200, "Made progress: %d, resume: %d\n", progress_percent, resume_possible);
+    } else {
+        snprintf(buffer, 200, "%s, made progress: %d, resume: %d\n", title, progress_percent, resume_possible);
+    }
+    log_printf(buffer);
+}
+
+void KNWarningCB(void* _, const char* warning) {
+    log_printf(warning);
+}
+
+void KNFlushErrorCB(void* _, const char* debug_message) {
+    log_printf(debug_message);
+}
+
+void KNFatalErrorCB(void* _, const char* debug_message, const char* user_message) {
+    log_printf(debug_message);
+    log_printf(user_message);
+}
+
+void VIQAddToProcessQueueCB(void* _, void* event) {
+    c_execute_event(event);
+    printf("C runtime: Processed event!\n");
+}
+
+void VIQEmptyQueueCB(void* _){}
+
+size_t VIQCallbacksPendingCB(void* _) { return 0; }
+
+int main(int argc, char* argv[]) {
+    log_printf("Creating logger\n");
+    c_set_logging_callback_and_start_logging(log_printf);
+
+    struct KernelNotificationInterfaceCallbacks kn_cbs = {
+        .user_data = NULL,
+        .block_tip = KNBlockTipCB,
+        .header_tip = KNHeaderTipCB,
+        .progress = KNProgressCB,
+        .warning = KNWarningCB,
+        .flush_error = KNFlushErrorCB,
+        .fatal_error = KNFatalErrorCB
+    };
+
+    struct ValidationInterfaceQueueCallbacks viq_cbs = {
+        .user_data = NULL,
+        .add_to_process_queue = VIQAddToProcessQueueCB,
+        .empty_queue = VIQEmptyQueueCB,
+        .callbacks_pending = VIQCallbacksPendingCB
+    };
+
+    log_printf("Creating context\n");
+    void* context = c_context_new(kn_cbs, viq_cbs);
+    if (context == NULL)
+    {
+        log_printf("Failed to create context\n");
+        return -1;
+    }
+    log_printf("Bitcoin context created\n");
+
+    log_printf("Creating chainstate manager\n");
+    void* chainman = c_chainstate_manager_create("/home/drgrid/.bitcoin/signet", context);
+    log_printf("Bitcoin chainstate manager created\n");
+
+    if (chainman == NULL) {
+        log_printf("Failed to create chainstate manager\n");
+        return -1;
+    }
+    log_printf("created chainstate manager\n");
+
+    void* cursor = c_chainstate_coins_cursor(chainman);
+    c_coins_cursor_delete(cursor);
+
+    log_printf("Validating invald Bitcoin block\n");
+    c_chainstate_manager_validate_block(chainman, context, "deadbeef");
+    log_printf("Validated an invalid Bitcoin block, validating another invalid block.\n");
+    c_chainstate_manager_validate_block(chainman, context, "deadbeef");
+    log_printf("Validated invald Bitcoin block\n");
+
+    log_printf("Freeing chainstate resources\n");
+    c_chainstate_manager_delete(chainman, context);
+    log_printf("Freed chainstate resources\n");
+
+    log_printf("Freeing context resources\n");
+    c_context_delete(context);
+    log_printf("Freed context resources\n");
+
+    return 0;
+}
diff --git a/src/bitcoinkernel.h b/src/bitcoinkernel.h
new file mode 100644
index 00000000000000..f11aec0c46243f
--- /dev/null
+++ b/src/bitcoinkernel.h
@@ -0,0 +1,106 @@
+#ifndef _BITCOIN_CHAINSTATE_WRAPPER
+#define _BITCOIN_CHAINSTATE_WRAPPER
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#else
+#include <cstddef>
+#include <cstdint>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*LogCallback)(const char* message);
+
+typedef void (*VIQAddToProcessQueue)(void* user_data, void* event);
+typedef void (*VIQEmptyQueue)(void* user_data);
+typedef size_t (*VIQCallbacksPending)(void* user_data);
+
+struct ValidationInterfaceQueueCallbacks {
+    void* user_data;
+    VIQAddToProcessQueue add_to_process_queue;
+    VIQEmptyQueue empty_queue;
+    VIQCallbacksPending callbacks_pending;
+};
+
+/** Current sync state passed to tip changed callbacks. */
+enum C_SynchronizationState {
+    INIT_REINDEX,
+    INIT_DOWNLOAD,
+    POST_INIT
+};
+
+typedef void (*KNBlockTip)(void* user_data, enum C_SynchronizationState state, void* index);
+typedef void (*KNHeaderTip)(void* user_data, enum C_SynchronizationState state, int64_t height, int64_t timestamp, bool presync);
+typedef void (*KNProgress)(void* user_data, const char* title, int progress_percent, bool resume_possible);
+typedef void (*KNWarning)(void* user_data, const char* warning);
+typedef void (*KNFlushError)(void* user_data, const char* debug_message);
+typedef void (*KNFatalError)(void* user_data, const char* debug_message, const char* user_message);
+
+struct KernelNotificationInterfaceCallbacks {
+    void* user_data;
+    KNBlockTip block_tip;
+    KNHeaderTip header_tip;
+    KNProgress progress;
+    KNWarning warning;
+    KNFlushError flush_error;
+    KNFatalError fatal_error;
+};
+
+typedef struct {
+    const char* path;
+    int reindexing;
+    int snapshot_active;
+    int active_height;
+    int active_ibd;
+} C_ChainstateInfo;
+
+typedef struct {
+    const uint8_t* data;
+    uint64_t len;
+} ByteArray;
+
+typedef struct {
+    uint8_t hash[32];
+    unsigned int n;
+} C_OutPoint;
+
+typedef struct {
+    long int value;
+    ByteArray script_pubkey;
+} C_TxOut;
+
+typedef struct {
+    C_TxOut out;
+    unsigned int is_coinbase;
+    unsigned int confirmation_height;
+} C_Coin;
+
+void c_set_logging_callback_and_start_logging(LogCallback callback);
+void* c_context_new(
+    struct KernelNotificationInterfaceCallbacks kn_cbs,
+    struct ValidationInterfaceQueueCallbacks viq_cbs
+);
+void c_context_delete(void* context);
+void c_execute_event(void* event);
+C_ChainstateInfo c_get_chainstate_info(void* chainman_);
+void* c_chainstate_manager_create(const char* data_dir, void* main_signals_);
+int c_chainstate_manager_validate_block(void* chainman_, void* main_signals_, const char* raw_block);
+int c_chainstate_manager_delete(void* chainman_, void* main_signals_);
+
+void* c_chainstate_coins_cursor(void* chainman_);
+void c_coins_cursor_next(void* cursor_);
+C_OutPoint c_coins_cursor_get_key(void* cursor_);
+C_Coin c_coins_cursor_get_value(void* cursor_);
+int c_coins_cursor_valid(void* cursor_);
+void c_coins_cursor_delete(void* cursor_);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _BITCOIN_CHAINSTATE_WRAPPER
diff --git a/src/validation.h b/src/validation.h
index 4dbd5be0881bbf..96899c2882e535 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -947,6 +947,8 @@ class ChainstateManager
      */
     void CheckBlockIndex();
 
+    bool healthy() const { return true; }
+
     /**
      * Alias for ::cs_main.
      * Should be used in new code to make it easier to make ::cs_main a member