Squashed 'libbitcoinkernel-sys/bitcoin/' changes from 34a8429ff3a..403c20980ec

403c20980ec kernel: Add pure kernel bitcoin-chainstate
2e1b262eff6 kernel: Add functions to get the block hash from a block
f0b56a6052a kernel: Add block index utility functions to C header
9393cf98179 kernel: Add function to read block undo data from disk to C header
e2ccfba0e3e kernel: Add functions to read block from disk to C header
0559575861c kernel: Add function for copying  block data to C header
7b02e52237e kernel: Add functions for the block validation state to C header
fdebacca7ad kernel: Add validation interface to C header
f4ea5f49c6d kernel: Add interrupt function to C header
5f4b436aad9 kernel: Add import blocks function to C header
c95a28fd80c kernel: Add chainstate load options for in-memory dbs in C header
d6360557ef6 kernel: Add options for reindexing in C header
a125867b9fe kernel: Add block validation to C header
b2b75a0ef73 Kernel: Add chainstate loading to kernel C header
d233003ff2a kernel: Add chainstate manager option for setting worker threads
REVERT: 34a8429ff3a kernel: Add pure kernel bitcoin-chainstate
REVERT: 6e9834d65e8 kernel: Add functions to get the block hash from a block
REVERT: 5ade5c2c879 kernel: Add block index utility functions to C header
REVERT: edc970c16fc kernel: Add function to read block undo data from disk to C header
REVERT: 27ae05ee614 kernel: Add functions to read block from disk to C header
REVERT: 2a31ff87c85 kernel: Add function for copying  block data to C header
REVERT: 18d44eb823d kernel: Add functions for the block validation state to C header
REVERT: 8a338185fa9 kernel: Add validation interface to C header
REVERT: abfb0549fdd kernel: Add interrupt function to C header
REVERT: fdf772a2918 kernel: Add import blocks function to C header
REVERT: a6175602cf5 kernel: Add chainstate load options for in-memory dbs in C header
REVERT: 72c57446910 kernel: Add options for reindexing in C header
REVERT: fe82b15ce02 kernel: Add block validation to C header
REVERT: 56b8a64947d Kernel: Add chainstate loading to kernel C header
REVERT: c3b34ce08d7 kernel: Add chainstate manager option for setting worker threads

git-subtree-dir: libbitcoinkernel-sys/bitcoin
git-subtree-split: 403c20980ec118f6efdd21d7c25646e20574583b

Author: bug-castercv502

src/kernel/bitcoin-chainstate.cpp

@@ -153,6 +153,8 @@ int main(int argc, char* argv[])
 
     TestKernelNotifications notifications{};
     options.SetNotifications(notifications);
+    TestValidationInterface validation_interface{};
+    options.SetValidationInterface(validation_interface);
 
     Context context{options};
     assert(context);

src/kernel/bitcoinkernel.cpp

@@ -192,9 +192,28 @@ class KernelNotifications : public kernel::Notifications
     }
 };
 
+class KernelValidationInterface final : public CValidationInterface
+{
+public:
+    const kernel_ValidationInterfaceCallbacks m_cbs;
+
+    explicit KernelValidationInterface(const kernel_ValidationInterfaceCallbacks vi_cbs) : m_cbs{vi_cbs} {}
+
+protected:
+    void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override
+    {
+        if (m_cbs.block_checked) {
+            m_cbs.block_checked((void*) m_cbs.user_data,
+                                reinterpret_cast<const kernel_BlockPointer*>(&block),
+                                reinterpret_cast<const kernel_BlockValidationState*>(&stateIn));
+        }
+    }
+};
+
 struct ContextOptions {
     std::unique_ptr<const KernelNotifications> m_notifications;
     std::unique_ptr<const CChainParams> m_chainparams;
+    std::unique_ptr<const KernelValidationInterface> m_validation_interface;
 };
 
 class Context
@@ -210,6 +229,8 @@ class Context
 
     std::unique_ptr<const CChainParams> m_chainparams;
 
+    std::unique_ptr<KernelValidationInterface> m_validation_interface;
+
     Context(const ContextOptions* options, bool& sane)
         : m_context{std::make_unique<kernel::Context>()},
           m_interrupt{std::make_unique<util::SignalInterrupt>()},
@@ -228,27 +249,19 @@ class Context
             m_chainparams = CChainParams::Main();
         }
 
+        if (options && options->m_validation_interface) {
+            m_validation_interface = std::make_unique<KernelValidationInterface>(*options->m_validation_interface);
+            m_signals->RegisterValidationInterface(m_validation_interface.get());
+        }
+
         if (!kernel::SanityChecks(*m_context)) {
             sane = false;
         }
     }
-};
 
-class KernelValidationInterface final : public CValidationInterface
-{
-public:
-    const kernel_ValidationInterfaceCallbacks m_cbs;
-
-    explicit KernelValidationInterface(const kernel_ValidationInterfaceCallbacks vi_cbs) : m_cbs{vi_cbs} {}
-
-protected:
-    void BlockChecked(const CBlock& block, const BlockValidationState& stateIn) override
+    ~Context()
     {
-        if (m_cbs.block_checked) {
-            m_cbs.block_checked((void*) m_cbs.user_data,
-                                reinterpret_cast<const kernel_BlockPointer*>(&block),
-                                reinterpret_cast<const kernel_BlockValidationState*>(&stateIn));
-        }
+        m_signals->UnregisterValidationInterface(m_validation_interface.get());
     }
 };
 
@@ -348,12 +361,6 @@ std::shared_ptr<CBlock>* cast_cblocksharedpointer(kernel_Block* block)
     return reinterpret_cast<std::shared_ptr<CBlock>*>(block);
 }
 
-std::shared_ptr<KernelValidationInterface>* cast_validation_interface(kernel_ValidationInterface* interface)
-{
-    assert(interface);
-    return reinterpret_cast<std::shared_ptr<KernelValidationInterface>*>(interface);
-}
-
 const BlockValidationState* cast_block_validation_state(const kernel_BlockValidationState* block_validation_state)
 {
     assert(block_validation_state);
@@ -633,6 +640,13 @@ void kernel_context_options_set_notifications(kernel_ContextOptions* options_, c
     options->m_notifications = std::make_unique<const KernelNotifications>(*notifications);
 }
 
+void kernel_context_options_set_validation_interface(kernel_ContextOptions* options_, kernel_ValidationInterfaceCallbacks vi_cbs)
+{
+    auto options{cast_context_options(options_)};
+    options->m_validation_interface = std::make_unique<KernelValidationInterface>(KernelValidationInterface(vi_cbs));
+    // return reinterpret_cast<kernel_ValidationInterface*>(new std::shared_ptr<KernelValidationInterface>(new KernelValidationInterface(vi_cbs)));
+}
+
 void kernel_context_options_destroy(kernel_ContextOptions* options)
 {
     if (options) {
@@ -666,42 +680,6 @@ void kernel_context_destroy(kernel_Context* context)
     }
 }
 
-kernel_ValidationInterface* kernel_validation_interface_create(kernel_ValidationInterfaceCallbacks vi_cbs)
-{
-    return reinterpret_cast<kernel_ValidationInterface*>(new std::shared_ptr<KernelValidationInterface>(new KernelValidationInterface(vi_cbs)));
-}
-
-bool kernel_validation_interface_register(kernel_Context* context_, kernel_ValidationInterface* validation_interface_)
-{
-    auto context{cast_context(context_)};
-    auto validation_interface{cast_validation_interface(validation_interface_)};
-    if (!context->m_signals) {
-        LogError("Cannot register validation interface with context that has no validation signals.\n");
-        return false;
-    }
-    context->m_signals->RegisterSharedValidationInterface(*validation_interface);
-    return true;
-}
-
-bool kernel_validation_interface_unregister(kernel_Context* context_, kernel_ValidationInterface* validation_interface_)
-{
-    auto context{cast_context(context_)};
-    auto validation_interface{cast_validation_interface(validation_interface_)};
-    if (!context->m_signals) {
-        LogError("Cannot de-register validation interface with context that has no validation signals.\n");
-        return false;
-    }
-    context->m_signals->UnregisterSharedValidationInterface(*validation_interface);
-    return true;
-}
-
-void kernel_validation_interface_destroy(kernel_ValidationInterface* validation_interface)
-{
-    if (validation_interface) {
-        delete cast_validation_interface(validation_interface);
-    }
-}
-
 kernel_ValidationMode kernel_get_validation_mode_from_block_validation_state(const kernel_BlockValidationState* block_validation_state_)
 {
     auto& block_validation_state = *cast_block_validation_state(block_validation_state_);
@@ -1035,7 +1013,7 @@ kernel_BlockIndex* kernel_get_block_index_from_genesis(const kernel_Context* con
     return reinterpret_cast<kernel_BlockIndex*>(WITH_LOCK(::cs_main, return chainman->ActiveChain().Genesis()));
 }
 
-kernel_BlockIndex* kernel_get_block_index_by_hash(const kernel_Context* context_, kernel_ChainstateManager* chainman_, kernel_BlockHash* block_hash)
+kernel_BlockIndex* kernel_get_block_index_from_hash(const kernel_Context* context_, kernel_ChainstateManager* chainman_, kernel_BlockHash* block_hash)
 {
     auto chainman{cast_chainstate_manager(chainman_)};
 
@@ -1048,7 +1026,7 @@ kernel_BlockIndex* kernel_get_block_index_by_hash(const kernel_Context* context_
     return reinterpret_cast<kernel_BlockIndex*>(block_index);
 }
 
-kernel_BlockIndex* kernel_get_block_index_by_height(const kernel_Context* context_, kernel_ChainstateManager* chainman_, int height)
+kernel_BlockIndex* kernel_get_block_index_from_height(const kernel_Context* context_, kernel_ChainstateManager* chainman_, int height)
 {
     auto chainman{cast_chainstate_manager(chainman_)};
 
@@ -1061,7 +1039,7 @@ kernel_BlockIndex* kernel_get_block_index_by_height(const kernel_Context* contex
     return reinterpret_cast<kernel_BlockIndex*>(chainman->ActiveChain()[height]);
 }
 
-kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, const kernel_BlockIndex* block_index_, kernel_ChainstateManager* chainman_)
+kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, kernel_ChainstateManager* chainman_, const kernel_BlockIndex* block_index_)
 {
     const auto block_index{cast_const_block_index(block_index_)};
     auto chainman{cast_chainstate_manager(chainman_)};

src/kernel/bitcoinkernel.h

@@ -641,6 +641,21 @@ void kernel_context_options_set_notifications(
     const kernel_Notifications* notifications
 ) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
+/**
+ * @brief Set the validation interface callbacks for the context options. The
+ * context created with the options will be configured for these validation
+ * interface callbacks. The callbacks will then be triggered from validation
+ * events issued by the chainstate manager created from the same context.
+ *
+ * @param[in] context_options                Non-null, previously created with kernel_context_options_create.
+ * @param[in] validation_interface_callbacks The callbacks used for passing validation information to the
+ *                                           user.
+ */
+void kernel_context_options_set_validation_interface(
+    kernel_ContextOptions* context_options,
+    kernel_ValidationInterfaceCallbacks validation_interface_callbacks
+) BITCOINKERNEL_ARG_NONNULL(1);
+
 /**
  * Destroy the context options.
  */
@@ -715,7 +730,8 @@ kernel_BlockManagerOptions* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_manage
  *
  * @param[in] chainstate_manager_options Non-null, options to be set.
  * @param[in] worker_threads The number of worker threads that should be spawned in the thread pool
- *                           used for validation. The number should be greater than 0.
+ *                           used for validation. The number must not be negative. When set to zero
+ *                           no parallel verification is done.
  */
 void kernel_chainstate_manager_options_set_worker_threads_num(
         kernel_ChainstateManagerOptions* chainstate_manager_options,
@@ -750,54 +766,6 @@ kernel_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_man
  */
 void kernel_chainstate_manager_destroy(kernel_ChainstateManager* chainstate_manager, const kernel_Context* context);
 
-/**
- * @brief Creates a new validation interface for consuming events issued by the
- * chainstate manager. The interface should be created and registered before the
- * chainstate manager is created to avoid missing validation events.
- *
- * @param[in] validation_interface_callbacks The callbacks used for passing validation information to the
- *                                           user.
- * @return                                   A validation interface. This should remain in memory for as
- *                                           long as the user expects to receive validation events.
- */
-kernel_ValidationInterface* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_validation_interface_create(
-    kernel_ValidationInterfaceCallbacks validation_interface_callbacks);
-
-/**
- * @brief Register a validation interface with the internal task runner
- * associated with this context. This also registers it with the chainstate
- * manager if the chainstate manager is subsequently created with this context.
- *
- * @param[in] context              Non-null, will register the validation interface with this context.
- * @param[in] validation_interface Non-null.
- * @return                         True on success.
- */
-bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_validation_interface_register(
-    kernel_Context* context,
-    kernel_ValidationInterface* validation_interface
-) BITCOINKERNEL_ARG_NONNULL(1, 2);
-
-/**
- * @brief Unregister a validation interface from the internal task runner
- * associated with this context. This should be done before destroying the
- * kernel context it was previously registered with.
- *
- * @param[in] context              Non-null, will deregister the validation interface from this context.
- * @param[in] validation_interface Non-null.
- * @return                         True on success.
- */
-bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_validation_interface_unregister(
-    kernel_Context* context,
-    kernel_ValidationInterface* validation_interface
-) BITCOINKERNEL_ARG_NONNULL(1, 2);
-
-/**
- * Destroy the validation interface. This should be done after unregistering it
- * if the validation interface was previously registered with a chainstate
- * manager.
- */
-void kernel_validation_interface_destroy(kernel_ValidationInterface* validation_interface);
-
 /**
  * Create options for loading the chainstate.
  */
@@ -1012,7 +980,7 @@ kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_from_
  * @param[in] block_hash         Non-null.
  * @return                       The block index of the block with the passed in hash, or null on error.
  */
-kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_by_hash(
+kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_from_hash(
     const kernel_Context* context,
     kernel_ChainstateManager* chainstate_manager,
     kernel_BlockHash* block_hash
@@ -1027,7 +995,7 @@ kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_by_ha
  * @param[in] block_height       Height in the chain of the to be retrieved block index.
  * @return                       The block index at a certain height in the currently active chain, or null on error.
  */
-kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_by_height(
+kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_from_height(
     const kernel_Context* context,
     kernel_ChainstateManager* chainstate_manager,
     int block_height
@@ -1045,8 +1013,8 @@ kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_block_index_by_he
  */
 kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_next_block_index(
     const kernel_Context* context,
-    const kernel_BlockIndex* block_index,
-    kernel_ChainstateManager* chainstate_manager
+    kernel_ChainstateManager* chainstate_manager,
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
 /**