Squashed 'libbitcoinkernel-sys/bitcoin/' changes from 73acb3ff8a04..f157b0cbc7d9

f157b0cbc7d9 kernel: Add pure kernel bitcoin-chainstate
692d1c23c272 kernel: Add functions to get the block hash from a block
aad02fb561ae kernel: Add block index utility functions to C header
13f4911b0646 kernel: Add function to read block undo data from disk to C header
29fdbf260348 kernel: Add functions to read block from disk to C header
2ca304c1def7 kernel: Add function for copying  block data to C header
705c7f125fd9 kernel: Add functions for the block validation state to C header
92363c9469c0 kernel: Add validation interface to C header
7c539908113b kernel: Add interrupt function to C header
522d0886d8ff kernel: Add import blocks function to C header
1ae86e2ffe12 kernel: Add chainstate load options for in-memory dbs in C header
09620eeeae6c kernel: Add options for reindexing in C header
b4fbf1931725 kernel: Add block validation to C header
ce6ddde95eee Kernel: Add chainstate loading to kernel C header
f5d21c94dc5a kernel: Add chainstate manager option for setting worker threads
783f56f0a290 kernel: Add chainstate manager object to C header
262039e4094c kernel: Add notifications context option to C header
dc0d406dd5e9 kerenl: Add chain params context option to C header
b5f84de7ad2d kernel: Add kernel library context object
dad0009c86c1 kernel: Add logging to kernel library C header
27e25aa941c6 kernel: Introduce initial kernel C header API
REVERT: 73acb3ff8a04 kernel: Add pure kernel bitcoin-chainstate
REVERT: 6c26da3dc494 kernel: Add functions to get the block hash from a block
REVERT: 99d302a824f5 kernel: Add block index utility functions to C header
REVERT: 7d1583ec269f kernel: Add function to read block undo data from disk to C header
REVERT: 7af127e174e8 kernel: Add functions to read block from disk to C header
REVERT: 700087ca1112 kernel: Add function for copying  block data to C header
REVERT: db9b5fa92db4 kernel: Add functions for the block validation state to C header
REVERT: ae178c846341 kernel: Add validation interface to C header
REVERT: f5ecbabe94d9 kernel: Add interrupt function to C header
REVERT: 08a52f02bf84 kernel: Add import blocks function to C header
REVERT: 3ced859f0f9f kernel: Add chainstate load options for in-memory dbs in C header
REVERT: b3a1f0c65ec0 kernel: Add options for reindexing in C header
REVERT: bde14cb16090 kernel: Add block validation to C header
REVERT: 3ebee13826d3 Kernel: Add chainstate loading to kernel C header
REVERT: 593999ab9a6c kernel: Add chainstate manager option for setting worker threads
REVERT: 78dda8e7474f kernel: Add chainstate manager object to C header
REVERT: 436db528893b kernel: Add notifications context option to C header
REVERT: 2e4e30d45c39 kerenl: Add chain params context option to C header
REVERT: 20f1d3996ec6 kernel: Add kernel library context object
REVERT: f3ab2302a1c3 kernel: Add logging to kernel library C header
REVERT: 20f5156bd517 kernel: Introduce initial kernel C header API

git-subtree-dir: libbitcoinkernel-sys/bitcoin
git-subtree-split: f157b0cbc7d90075858a6522d13a7bc4f0b25a5f

Author: bug-castercv502

src/kernel/bitcoin-chainstate.cpp

@@ -166,13 +166,11 @@ int main(int argc, char* argv[])
     chainman_opts.SetWorkerThreads(4);
     BlockManagerOptions blockman_opts{context, abs_datadir / "blocks"};
     assert(blockman_opts);
+    ChainstateLoadOptions chainstate_load_opts{};
 
-    auto chainman{std::make_unique<ChainMan>(context, chainman_opts, blockman_opts)};
+    auto chainman{std::make_unique<ChainMan>(context, chainman_opts, blockman_opts, chainstate_load_opts)};
     assert(chainman);
 
-    ChainstateLoadOptions chainstate_load_opts{};
-    assert(chainman->LoadChainstate(chainstate_load_opts));
-
     std::cout << "Enter the block you want to validate on the next line:" << std::endl;
 
     for (std::string line; std::getline(std::cin, line);) {

src/kernel/bitcoinkernel.cpp

@@ -757,23 +757,6 @@ void kernel_block_manager_options_destroy(kernel_BlockManagerOptions* options)
     }
 }
 
-kernel_ChainstateManager* kernel_chainstate_manager_create(
-    const kernel_Context* context_,
-    const kernel_ChainstateManagerOptions* chainman_opts_,
-    const kernel_BlockManagerOptions* blockman_opts_)
-{
-    auto chainman_opts{cast_const_chainstate_manager_options(chainman_opts_)};
-    auto blockman_opts{cast_const_block_manager_options(blockman_opts_)};
-    auto context{cast_const_context(context_)};
-
-    try {
-        return reinterpret_cast<kernel_ChainstateManager*>(new ChainstateManager{*context->m_interrupt, *chainman_opts, *blockman_opts});
-    } catch (const std::exception& e) {
-        LogError("Failed to create chainstate manager: %s", e.what());
-        return nullptr;
-    }
-}
-
 kernel_ChainstateLoadOptions* kernel_chainstate_load_options_create()
 {
     return reinterpret_cast<kernel_ChainstateLoadOptions*>(new node::ChainstateLoadOptions);
@@ -819,46 +802,65 @@ void kernel_chainstate_load_options_destroy(kernel_ChainstateLoadOptions* chains
     }
 }
 
-bool kernel_chainstate_manager_load_chainstate(const kernel_Context* context_,
-                                               const kernel_ChainstateLoadOptions* chainstate_load_opts_,
-                                               kernel_ChainstateManager* chainman_)
+kernel_ChainstateManager* kernel_chainstate_manager_create(
+    const kernel_Context* context_,
+    const kernel_ChainstateManagerOptions* chainman_opts_,
+    const kernel_BlockManagerOptions* blockman_opts_,
+    const kernel_ChainstateLoadOptions* chainstate_load_opts_)
 {
+    auto chainman_opts{cast_const_chainstate_manager_options(chainman_opts_)};
+    auto blockman_opts{cast_const_block_manager_options(blockman_opts_)};
+    auto context{cast_const_context(context_)};
+
+    ChainstateManager* chainman;
+
+    try {
+        chainman = new ChainstateManager{*context->m_interrupt, *chainman_opts, *blockman_opts};
+    } catch (const std::exception& e) {
+        LogError("Failed to create chainstate manager: %s", e.what());
+        return nullptr;
+    }
+
     try {
         const auto& chainstate_load_opts{*cast_const_chainstate_load_options(chainstate_load_opts_)};
-        auto& chainman{*cast_chainstate_manager(chainman_)};
 
         if (chainstate_load_opts.wipe_block_tree_db && !chainstate_load_opts.wipe_chainstate_db) {
             LogWarning("Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
-            return false;
+            kernel_chainstate_manager_destroy(reinterpret_cast<kernel_ChainstateManager*>(chainman), context_);
+            return nullptr;
         }
 
         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);
-        auto [status, chainstate_err]{node::LoadChainstate(chainman, cache_sizes, chainstate_load_opts)};
+        auto [status, chainstate_err]{node::LoadChainstate(*chainman, cache_sizes, chainstate_load_opts)};
         if (status != node::ChainstateLoadStatus::SUCCESS) {
             LogError("Failed to load chain state from your data directory: %s", chainstate_err.original);
-            return false;
+            kernel_chainstate_manager_destroy(reinterpret_cast<kernel_ChainstateManager*>(chainman), context_);
+            return nullptr;
         }
-        std::tie(status, chainstate_err) = node::VerifyLoadedChainstate(chainman, chainstate_load_opts);
+        std::tie(status, chainstate_err) = node::VerifyLoadedChainstate(*chainman, chainstate_load_opts);
         if (status != node::ChainstateLoadStatus::SUCCESS) {
             LogError("Failed to verify loaded chain state from your datadir: %s", chainstate_err.original);
-            return false;
+            kernel_chainstate_manager_destroy(reinterpret_cast<kernel_ChainstateManager*>(chainman), context_);
+            return nullptr;
         }
 
-        for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman.GetAll())) {
+        for (Chainstate* chainstate : WITH_LOCK(::cs_main, return chainman->GetAll())) {
             BlockValidationState state;
             if (!chainstate->ActivateBestChain(state, nullptr)) {
                 LogError("Failed to connect best block: %s", state.ToString());
-                return false;
+                kernel_chainstate_manager_destroy(reinterpret_cast<kernel_ChainstateManager*>(chainman), context_);
+                return nullptr;
             }
         }
     } catch (const std::exception& e) {
         LogError("Failed to load chainstate: %s", e.what());
-        return false;
+        return nullptr;
     }
-    return true;
+
+    return reinterpret_cast<kernel_ChainstateManager*>(chainman);
 }
 
 void kernel_chainstate_manager_destroy(kernel_ChainstateManager* chainman_, const kernel_Context* context_)