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

TheCharlatan · TheCharlatan · commit 4cef0f9abb9e · 2024-11-22T14:43:29.000+01:00
34a8429ff3a kernel: Add pure kernel bitcoin-chainstate
6e9834d65e8 kernel: Add functions to get the block hash from a block
5ade5c2c879 kernel: Add block index utility functions to C header
edc970c16fc kernel: Add function to read block undo data from disk to C header
27ae05ee614 kernel: Add functions to read block from disk to C header
2a31ff87c85 kernel: Add function for copying  block data to C header
18d44eb823d kernel: Add functions for the block validation state to C header
8a338185fa9 kernel: Add validation interface to C header
abfb0549fdd kernel: Add interrupt function to C header
fdf772a2918 kernel: Add import blocks function to C header
a6175602cf5 kernel: Add chainstate load options for in-memory dbs in C header
72c57446910 kernel: Add options for reindexing in C header
fe82b15ce02 kernel: Add block validation to C header
56b8a64947d Kernel: Add chainstate loading to kernel C header
c3b34ce08d7 kernel: Add chainstate manager option for setting worker threads
3610be3b138 kernel: Add chainstate manager object to C header
c194bea41f6 kernel: Add notifications context option to C header
691d89d846b kerenl: Add chain params context option to C header
407ca750cda kernel: Add kernel library context object
ee3c4ea92cd kernel: Add logging to kernel library C header
e6c610a7e03 kernel: Introduce initial kernel C header API
REVERT: fc67047b7e1 kernel: Add pure kernel bitcoin-chainstate
REVERT: e2116031253 kernel: Add functions to get the block hash from a block
REVERT: 2ae6547941f kernel: Add block index utility functions to C header
REVERT: f09d42fff2b kernel: Add function to read block undo data from disk to C header
REVERT: 52aedd024b0 kernel: Add functions to read block from disk to C header
REVERT: 6d2bdce9923 kernel: Add function for copying  block data to C header
REVERT: e3b16b2677a kernel: Add functions for the block validation state to C header
REVERT: 8de0bd040f4 kernel: Add validation interface to C header
REVERT: 84abd35f72a kernel: Add interrupt function to C header
REVERT: 260fb3e0584 kernel: Add import blocks function to C header
REVERT: 971bb20e9c8 kernel: Add chainstate load options for in-memory dbs in C header
REVERT: 1af8c906fc7 kernel: Add options for reindexing in C header
REVERT: 055d2ed419e kernel: Add block validation to C header
REVERT: 39850656a04 Kernel: Add chainstate loading to kernel C header
REVERT: 06d26f0bfa6 kernel: Add chainstate manager option for setting worker threads
REVERT: a3d46f4bf64 kernel: Add chainstate manager object to C header
REVERT: d2e2da933b7 kernel: Add notifications context option to C header
REVERT: 1337539a0b3 kerenl: Add chain params context option to C header
REVERT: 778330c21f0 kernel: Add kernel library context object
REVERT: a54b59d8100 kernel: Add logging to kernel library C header
REVERT: 4fe7162698d kernel: Introduce initial kernel C header API

git-subtree-dir: libbitcoinkernel-sys/bitcoin
git-subtree-split: 34a8429ff3a870c0caaf4c4790becd86c5acde38
diff --git a/src/kernel/bitcoinkernel.cpp b/src/kernel/bitcoinkernel.cpp
@@ -306,16 +306,22 @@ const Context* cast_const_context(const kernel_Context* context)
     return reinterpret_cast<const Context*>(context);
 }
 
+const ChainstateManager::Options* cast_const_chainstate_manager_options(const kernel_ChainstateManagerOptions* options)
+{
+    assert(options);
+    return reinterpret_cast<const ChainstateManager::Options*>(options);
+}
+
 ChainstateManager::Options* cast_chainstate_manager_options(kernel_ChainstateManagerOptions* options)
 {
     assert(options);
     return reinterpret_cast<ChainstateManager::Options*>(options);
 }
 
-node::BlockManager::Options* cast_block_manager_options(kernel_BlockManagerOptions* options)
+const node::BlockManager::Options* cast_const_block_manager_options(const kernel_BlockManagerOptions* options)
 {
     assert(options);
-    return reinterpret_cast<node::BlockManager::Options*>(options);
+    return reinterpret_cast<const node::BlockManager::Options*>(options);
 }
 
 ChainstateManager* cast_chainstate_manager(kernel_ChainstateManager* chainman)
@@ -330,6 +336,12 @@ node::ChainstateLoadOptions* cast_chainstate_load_options(kernel_ChainstateLoadO
     return reinterpret_cast<node::ChainstateLoadOptions*>(options);
 }
 
+const node::ChainstateLoadOptions* cast_const_chainstate_load_options(const kernel_ChainstateLoadOptions* options)
+{
+    assert(options);
+    return reinterpret_cast<const node::ChainstateLoadOptions*>(options);
+}
+
 std::shared_ptr<CBlock>* cast_cblocksharedpointer(kernel_Block* block)
 {
     assert(block);
@@ -354,16 +366,16 @@ const CBlock* cast_const_cblock(const kernel_BlockPointer* block)
     return reinterpret_cast<const CBlock*>(block);
 }
 
-CBlockIndex* cast_block_index(kernel_BlockIndex* index)
+const CBlockIndex* cast_const_block_index(const kernel_BlockIndex* index)
 {
     assert(index);
-    return reinterpret_cast<CBlockIndex*>(index);
+    return reinterpret_cast<const CBlockIndex*>(index);
 }
 
-CBlockUndo* cast_block_undo(kernel_BlockUndo* undo)
+const CBlockUndo* cast_const_block_undo(const kernel_BlockUndo* undo)
 {
     assert(undo);
-    return reinterpret_cast<CBlockUndo*>(undo);
+    return reinterpret_cast<const CBlockUndo*>(undo);
 }
 
 } // namespace
@@ -412,7 +424,7 @@ void kernel_script_pubkey_destroy(kernel_ScriptPubkey* script_pubkey)
     }
 }
 
-kernel_TransactionOutput* kernel_transaction_output_create(kernel_ScriptPubkey* script_pubkey_, int64_t amount)
+kernel_TransactionOutput* kernel_transaction_output_create(const kernel_ScriptPubkey* script_pubkey_, int64_t amount)
 {
     const auto& script_pubkey{*cast_script_pubkey(script_pubkey_)};
     const CAmount& value{amount};
@@ -593,7 +605,7 @@ kernel_Notifications* kernel_notifications_create(kernel_NotificationInterfaceCa
     return reinterpret_cast<kernel_Notifications*>(new KernelNotifications{callbacks});
 }
 
-void kernel_notifications_destroy(const kernel_Notifications* notifications)
+void kernel_notifications_destroy(kernel_Notifications* notifications)
 {
     if (notifications) {
         delete cast_const_notifications(notifications);
@@ -752,7 +764,7 @@ void kernel_chainstate_manager_options_set_worker_threads_num(kernel_ChainstateM
 void kernel_chainstate_manager_options_destroy(kernel_ChainstateManagerOptions* options)
 {
     if (options) {
-        delete cast_chainstate_manager_options(options);
+        delete cast_const_chainstate_manager_options(options);
     }
 }
 
@@ -778,17 +790,17 @@ kernel_BlockManagerOptions* kernel_block_manager_options_create(const kernel_Con
 void kernel_block_manager_options_destroy(kernel_BlockManagerOptions* options)
 {
     if (options) {
-        delete cast_block_manager_options(options);
+        delete cast_const_block_manager_options(options);
     }
 }
 
 kernel_ChainstateManager* kernel_chainstate_manager_create(
     const kernel_Context* context_,
-    kernel_ChainstateManagerOptions* chainman_opts_,
-    kernel_BlockManagerOptions* blockman_opts_)
+    const kernel_ChainstateManagerOptions* chainman_opts_,
+    const kernel_BlockManagerOptions* blockman_opts_)
 {
-    auto chainman_opts{cast_chainstate_manager_options(chainman_opts_)};
-    auto blockman_opts{cast_block_manager_options(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 {
@@ -840,16 +852,16 @@ void kernel_chainstate_load_options_set_chainstate_db_in_memory(
 void kernel_chainstate_load_options_destroy(kernel_ChainstateLoadOptions* chainstate_load_opts)
 {
     if (chainstate_load_opts) {
-        delete cast_chainstate_load_options(chainstate_load_opts);
+        delete cast_const_chainstate_load_options(chainstate_load_opts);
     }
 }
 
 bool kernel_chainstate_manager_load_chainstate(const kernel_Context* context_,
-                                               kernel_ChainstateLoadOptions* chainstate_load_opts_,
+                                               const kernel_ChainstateLoadOptions* chainstate_load_opts_,
                                                kernel_ChainstateManager* chainman_)
 {
     try {
-        auto& chainstate_load_opts{*cast_chainstate_load_options(chainstate_load_opts_)};
+        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) {
@@ -1049,9 +1061,9 @@ 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_, kernel_BlockIndex* block_index_, kernel_ChainstateManager* chainman_)
+kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, const kernel_BlockIndex* block_index_, kernel_ChainstateManager* chainman_)
 {
-    auto block_index{cast_block_index(block_index_)};
+    const auto block_index{cast_const_block_index(block_index_)};
     auto chainman{cast_chainstate_manager(chainman_)};
 
     auto next_block_index{WITH_LOCK(::cs_main, return chainman->ActiveChain().Next(block_index))};
@@ -1063,9 +1075,9 @@ kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, k
     return reinterpret_cast<kernel_BlockIndex*>(next_block_index);
 }
 
-kernel_BlockIndex* kernel_get_previous_block_index(kernel_BlockIndex* block_index_)
+kernel_BlockIndex* kernel_get_previous_block_index(const kernel_BlockIndex* block_index_)
 {
-    CBlockIndex* block_index{cast_block_index(block_index_)};
+    const CBlockIndex* block_index{cast_const_block_index(block_index_)};
 
     if (!block_index->pprev) {
         LogTrace(BCLog::KERNEL, "The block index is the genesis, it has no previous.\n");
@@ -1077,10 +1089,10 @@ kernel_BlockIndex* kernel_get_previous_block_index(kernel_BlockIndex* block_inde
 
 kernel_Block* kernel_read_block_from_disk(const kernel_Context* context_,
                                           kernel_ChainstateManager* chainman_,
-                                          kernel_BlockIndex* block_index_)
+                                          const kernel_BlockIndex* block_index_)
 {
     auto chainman{cast_chainstate_manager(chainman_)};
-    CBlockIndex* block_index{cast_block_index(block_index_)};
+    const CBlockIndex* block_index{cast_const_block_index(block_index_)};
 
     auto block{new std::shared_ptr<CBlock>(new CBlock{})};
     if (!chainman->m_blockman.ReadBlockFromDisk(**block, *block_index)) {
@@ -1092,10 +1104,10 @@ kernel_Block* kernel_read_block_from_disk(const kernel_Context* context_,
 
 kernel_BlockUndo* kernel_read_block_undo_from_disk(const kernel_Context* context_,
                                                    kernel_ChainstateManager* chainman_,
-                                                   kernel_BlockIndex* block_index_)
+                                                   const kernel_BlockIndex* block_index_)
 {
     auto chainman{cast_chainstate_manager(chainman_)};
-    auto block_index{cast_block_index(block_index_)};
+    const auto block_index{cast_const_block_index(block_index_)};
 
     if (block_index->nHeight < 1) {
         LogError("The genesis block does not have undo data.\n");
@@ -1115,30 +1127,30 @@ void kernel_block_index_destroy(kernel_BlockIndex* block_index)
     return;
 }
 
-uint64_t kernel_block_undo_size(kernel_BlockUndo* block_undo_)
+uint64_t kernel_block_undo_size(const kernel_BlockUndo* block_undo_)
 {
-    auto block_undo{cast_block_undo(block_undo_)};
+    const auto block_undo{cast_const_block_undo(block_undo_)};
     return block_undo->vtxundo.size();
 }
 
 void kernel_block_undo_destroy(kernel_BlockUndo* block_undo)
 {
     if (block_undo) {
-        delete cast_block_undo(block_undo);
+        delete cast_const_block_undo(block_undo);
     }
 }
 
-uint64_t kernel_get_transaction_undo_size(kernel_BlockUndo* block_undo_, uint64_t transaction_undo_index)
+uint64_t kernel_get_transaction_undo_size(const kernel_BlockUndo* block_undo_, uint64_t transaction_undo_index)
 {
-    auto block_undo{cast_block_undo(block_undo_)};
+    const auto block_undo{cast_const_block_undo(block_undo_)};
     return block_undo->vtxundo[transaction_undo_index].vprevout.size();
 }
 
-kernel_TransactionOutput* kernel_get_undo_output_by_index(kernel_BlockUndo* block_undo_,
+kernel_TransactionOutput* kernel_get_undo_output_by_index(const kernel_BlockUndo* block_undo_,
                                                           uint64_t transaction_undo_index,
                                                           uint64_t output_index)
 {
-    auto block_undo{cast_block_undo(block_undo_)};
+    const auto block_undo{cast_const_block_undo(block_undo_)};
 
     if (transaction_undo_index >= block_undo->vtxundo.size()) {
         LogInfo("transaction undo index is out of bounds.\n");
@@ -1156,15 +1168,15 @@ kernel_TransactionOutput* kernel_get_undo_output_by_index(kernel_BlockUndo* bloc
     return reinterpret_cast<kernel_TransactionOutput*>(prevout);
 }
 
-int32_t kernel_block_index_get_height(kernel_BlockIndex* block_index_)
+int32_t kernel_block_index_get_height(const kernel_BlockIndex* block_index_)
 {
-    auto block_index{cast_block_index(block_index_)};
+    auto block_index{cast_const_block_index(block_index_)};
     return block_index->nHeight;
 }
 
-kernel_BlockHash* kernel_block_index_get_block_hash(kernel_BlockIndex* block_index_)
+kernel_BlockHash* kernel_block_index_get_block_hash(const kernel_BlockIndex* block_index_)
 {
-    auto block_index{cast_block_index(block_index_)};
+    auto block_index{cast_const_block_index(block_index_)};
     if (block_index->phashBlock == nullptr) {
         return nullptr;
     }
diff --git a/src/kernel/bitcoinkernel.h b/src/kernel/bitcoinkernel.h
@@ -486,7 +486,7 @@ void kernel_script_pubkey_destroy(kernel_ScriptPubkey* script_pubkey);
  * @return                  The transaction output.
  */
 kernel_TransactionOutput* kernel_transaction_output_create(
-    kernel_ScriptPubkey* script_pubkey,
+    const kernel_ScriptPubkey* script_pubkey,
     int64_t amount
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
@@ -610,7 +610,7 @@ kernel_Notifications* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_notifications_crea
 /**
  * Destroy the kernel notifications.
  */
-void kernel_notifications_destroy(const kernel_Notifications* notifications);
+void kernel_notifications_destroy(kernel_Notifications* notifications);
 
 /**
  * Creates an empty context options.
@@ -741,8 +741,8 @@ void kernel_block_manager_options_destroy(kernel_BlockManagerOptions* block_mana
  */
 kernel_ChainstateManager* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_manager_create(
     const kernel_Context* context,
-    kernel_ChainstateManagerOptions* chainstate_manager_options,
-    kernel_BlockManagerOptions* block_manager_options
+    const kernel_ChainstateManagerOptions* chainstate_manager_options,
+    const kernel_BlockManagerOptions* block_manager_options
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
 /**
@@ -863,7 +863,7 @@ void kernel_chainstate_load_options_destroy(kernel_ChainstateLoadOptions* chains
  */
 bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_chainstate_manager_load_chainstate(
     const kernel_Context* context,
-    kernel_ChainstateLoadOptions* chainstate_load_options,
+    const kernel_ChainstateLoadOptions* chainstate_load_options,
     kernel_ChainstateManager* chainstate_manager
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
@@ -1045,7 +1045,7 @@ 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,
-    kernel_BlockIndex* block_index,
+    const kernel_BlockIndex* block_index,
     kernel_ChainstateManager* chainstate_manager
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
@@ -1057,7 +1057,7 @@ kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_next_block_index(
  * @return                The previous block index, or null on error or if the current block index is the genesis block.
  */
 kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_previous_block_index(
-    kernel_BlockIndex* block_index
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
@@ -1072,7 +1072,7 @@ kernel_BlockIndex* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_previous_block_in
 kernel_Block* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_read_block_from_disk(
     const kernel_Context* context,
     kernel_ChainstateManager* chainstate_manager,
-    kernel_BlockIndex* block_index
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
 /**
@@ -1087,7 +1087,7 @@ kernel_Block* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_read_block_from_disk(
 kernel_BlockUndo* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_read_block_undo_from_disk(
     const kernel_Context* context,
     kernel_ChainstateManager* chainstate_manager,
-    kernel_BlockIndex* block_index
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1, 2, 3);
 
 /**
@@ -1103,7 +1103,7 @@ void kernel_block_index_destroy(kernel_BlockIndex* block_index);
  * @return               The number of transaction undo data in the block undo.
  */
 uint64_t BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_undo_size(
-    kernel_BlockUndo* block_undo
+    const kernel_BlockUndo* block_undo
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
@@ -1120,7 +1120,7 @@ void kernel_block_undo_destroy(kernel_BlockUndo* block_undo);
  * @return                           The number of previous transaction outputs in the transaction.
  */
 uint64_t BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_transaction_undo_size(
-    kernel_BlockUndo* block_undo,
+    const kernel_BlockUndo* block_undo,
     uint64_t transaction_undo_index
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
@@ -1135,7 +1135,7 @@ uint64_t BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_transaction_undo_size(
  * @return                           A transaction output pointer, or null on error.
  */
 kernel_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_undo_output_by_index(
-    kernel_BlockUndo* block_undo,
+    const kernel_BlockUndo* block_undo,
     uint64_t transaction_undo_index,
     uint64_t output_index
 ) BITCOINKERNEL_ARG_NONNULL(1);
@@ -1147,7 +1147,7 @@ kernel_TransactionOutput* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_get_undo_outpu
  * @return                The block height.
  */
 int32_t BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_index_get_height(
-    kernel_BlockIndex* block_index
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
@@ -1157,7 +1157,7 @@ int32_t BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_index_get_height(
  * @return    The block hash.
  */
 kernel_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT kernel_block_index_get_block_hash(
-    kernel_BlockIndex* block_index
+    const kernel_BlockIndex* block_index
 ) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
diff --git a/src/kernel/bitcoinkernel_wrapper.h b/src/kernel/bitcoinkernel_wrapper.h
@@ -173,7 +173,7 @@ class KernelNotifications
 {
 private:
     struct Deleter {
-        void operator()(const kernel_Notifications* ptr) const
+        void operator()(kernel_Notifications* ptr) const
         {
             kernel_notifications_destroy(ptr);
         }
@@ -201,7 +201,7 @@ class KernelNotifications
         };
     }
 
-    std::unique_ptr<const kernel_Notifications, Deleter> m_notifications;
+    std::unique_ptr<kernel_Notifications, Deleter> m_notifications;
 
 public:
     KernelNotifications() : m_notifications{kernel_notifications_create(MakeCallbacks())} {}

Original file line number	Diff line number	Diff line change
`@@ -306,16 +306,22 @@ const Context* cast_const_context(const kernel_Context* context)`
`306`	`306`	`return reinterpret_cast<const Context*>(context);`
`307`	`307`	`}`
`308`	`308`
	`309`	`+const ChainstateManager::Options* cast_const_chainstate_manager_options(const kernel_ChainstateManagerOptions* options)`
	`310`	`+{`
	`311`	`+ assert(options);`
	`312`	`+ return reinterpret_cast<const ChainstateManager::Options*>(options);`
	`313`	`+}`
	`314`	`+`
`309`	`315`	`ChainstateManager::Options* cast_chainstate_manager_options(kernel_ChainstateManagerOptions* options)`
`310`	`316`	`{`
`311`	`317`	`assert(options);`
`312`	`318`	`return reinterpret_cast<ChainstateManager::Options*>(options);`
`313`	`319`	`}`
`314`	`320`
`315`		`-node::BlockManager::Options* cast_block_manager_options(kernel_BlockManagerOptions* options)`
	`321`	`+const node::BlockManager::Options* cast_const_block_manager_options(const kernel_BlockManagerOptions* options)`
`316`	`322`	`{`
`317`	`323`	`assert(options);`
`318`		`- return reinterpret_cast<node::BlockManager::Options*>(options);`
	`324`	`+ return reinterpret_cast<const node::BlockManager::Options*>(options);`
`319`	`325`	`}`
`320`	`326`
`321`	`327`	`ChainstateManager* cast_chainstate_manager(kernel_ChainstateManager* chainman)`
`@@ -330,6 +336,12 @@ node::ChainstateLoadOptions* cast_chainstate_load_options(kernel_ChainstateLoadO`
`330`	`336`	`return reinterpret_cast<node::ChainstateLoadOptions*>(options);`
`331`	`337`	`}`
`332`	`338`
	`339`	`+const node::ChainstateLoadOptions* cast_const_chainstate_load_options(const kernel_ChainstateLoadOptions* options)`
	`340`	`+{`
	`341`	`+ assert(options);`
	`342`	`+ return reinterpret_cast<const node::ChainstateLoadOptions*>(options);`
	`343`	`+}`
	`344`	`+`
`333`	`345`	`std::shared_ptr<CBlock>* cast_cblocksharedpointer(kernel_Block* block)`
`334`	`346`	`{`
`335`	`347`	`assert(block);`
`@@ -354,16 +366,16 @@ const CBlock* cast_const_cblock(const kernel_BlockPointer* block)`
`354`	`366`	`return reinterpret_cast<const CBlock*>(block);`
`355`	`367`	`}`
`356`	`368`
`357`		`-CBlockIndex* cast_block_index(kernel_BlockIndex* index)`
	`369`	`+const CBlockIndex* cast_const_block_index(const kernel_BlockIndex* index)`
`358`	`370`	`{`
`359`	`371`	`assert(index);`
`360`		`- return reinterpret_cast<CBlockIndex*>(index);`
	`372`	`+ return reinterpret_cast<const CBlockIndex*>(index);`
`361`	`373`	`}`
`362`	`374`
`363`		`-CBlockUndo* cast_block_undo(kernel_BlockUndo* undo)`
	`375`	`+const CBlockUndo* cast_const_block_undo(const kernel_BlockUndo* undo)`
`364`	`376`	`{`
`365`	`377`	`assert(undo);`
`366`		`- return reinterpret_cast<CBlockUndo*>(undo);`
	`378`	`+ return reinterpret_cast<const CBlockUndo*>(undo);`
`367`	`379`	`}`
`368`	`380`
`369`	`381`	`} // namespace`
`@@ -412,7 +424,7 @@ void kernel_script_pubkey_destroy(kernel_ScriptPubkey* script_pubkey)`
`412`	`424`	`}`
`413`	`425`	`}`
`414`	`426`
`415`		`-kernel_TransactionOutput* kernel_transaction_output_create(kernel_ScriptPubkey* script_pubkey_, int64_t amount)`
	`427`	`+kernel_TransactionOutput* kernel_transaction_output_create(const kernel_ScriptPubkey* script_pubkey_, int64_t amount)`
`416`	`428`	`{`
`417`	`429`	`const auto& script_pubkey{*cast_script_pubkey(script_pubkey_)};`
`418`	`430`	`const CAmount& value{amount};`
`@@ -593,7 +605,7 @@ kernel_Notifications* kernel_notifications_create(kernel_NotificationInterfaceCa`
`593`	`605`	`return reinterpret_cast<kernel_Notifications*>(new KernelNotifications{callbacks});`
`594`	`606`	`}`
`595`	`607`
`596`		`-void kernel_notifications_destroy(const kernel_Notifications* notifications)`
	`608`	`+void kernel_notifications_destroy(kernel_Notifications* notifications)`
`597`	`609`	`{`
`598`	`610`	`if (notifications) {`
`599`	`611`	`delete cast_const_notifications(notifications);`
`@@ -752,7 +764,7 @@ void kernel_chainstate_manager_options_set_worker_threads_num(kernel_ChainstateM`
`752`	`764`	`void kernel_chainstate_manager_options_destroy(kernel_ChainstateManagerOptions* options)`
`753`	`765`	`{`
`754`	`766`	`if (options) {`
`755`		`- delete cast_chainstate_manager_options(options);`
	`767`	`+ delete cast_const_chainstate_manager_options(options);`
`756`	`768`	`}`
`757`	`769`	`}`
`758`	`770`
`@@ -778,17 +790,17 @@ kernel_BlockManagerOptions* kernel_block_manager_options_create(const kernel_Con`
`778`	`790`	`void kernel_block_manager_options_destroy(kernel_BlockManagerOptions* options)`
`779`	`791`	`{`
`780`	`792`	`if (options) {`
`781`		`- delete cast_block_manager_options(options);`
	`793`	`+ delete cast_const_block_manager_options(options);`
`782`	`794`	`}`
`783`	`795`	`}`
`784`	`796`
`785`	`797`	`kernel_ChainstateManager* kernel_chainstate_manager_create(`
`786`	`798`	`const kernel_Context* context_,`
`787`		`- kernel_ChainstateManagerOptions* chainman_opts_,`
`788`		`- kernel_BlockManagerOptions* blockman_opts_)`
	`799`	`+ const kernel_ChainstateManagerOptions* chainman_opts_,`
	`800`	`+ const kernel_BlockManagerOptions* blockman_opts_)`
`789`	`801`	`{`
`790`		`- auto chainman_opts{cast_chainstate_manager_options(chainman_opts_)};`
`791`		`- auto blockman_opts{cast_block_manager_options(blockman_opts_)};`
	`802`	`+ auto chainman_opts{cast_const_chainstate_manager_options(chainman_opts_)};`
	`803`	`+ auto blockman_opts{cast_const_block_manager_options(blockman_opts_)};`
`792`	`804`	`auto context{cast_const_context(context_)};`
`793`	`805`
`794`	`806`	`try {`
`@@ -840,16 +852,16 @@ void kernel_chainstate_load_options_set_chainstate_db_in_memory(`
`840`	`852`	`void kernel_chainstate_load_options_destroy(kernel_ChainstateLoadOptions* chainstate_load_opts)`
`841`	`853`	`{`
`842`	`854`	`if (chainstate_load_opts) {`
`843`		`- delete cast_chainstate_load_options(chainstate_load_opts);`
	`855`	`+ delete cast_const_chainstate_load_options(chainstate_load_opts);`
`844`	`856`	`}`
`845`	`857`	`}`
`846`	`858`
`847`	`859`	`bool kernel_chainstate_manager_load_chainstate(const kernel_Context* context_,`
`848`		`- kernel_ChainstateLoadOptions* chainstate_load_opts_,`
	`860`	`+ const kernel_ChainstateLoadOptions* chainstate_load_opts_,`
`849`	`861`	`kernel_ChainstateManager* chainman_)`
`850`	`862`	`{`
`851`	`863`	`try {`
`852`		`- auto& chainstate_load_opts{*cast_chainstate_load_options(chainstate_load_opts_)};`
	`864`	`+ const auto& chainstate_load_opts{*cast_const_chainstate_load_options(chainstate_load_opts_)};`
`853`	`865`	`auto& chainman{*cast_chainstate_manager(chainman_)};`
`854`	`866`
`855`	`867`	`if (chainstate_load_opts.wipe_block_tree_db && !chainstate_load_opts.wipe_chainstate_db) {`
`@@ -1049,9 +1061,9 @@ kernel_BlockIndex* kernel_get_block_index_by_height(const kernel_Context* contex`
`1049`	`1061`	`return reinterpret_cast<kernel_BlockIndex*>(chainman->ActiveChain()[height]);`
`1050`	`1062`	`}`
`1051`	`1063`
`1052`		`-kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, kernel_BlockIndex* block_index_, kernel_ChainstateManager* chainman_)`
	`1064`	`+kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, const kernel_BlockIndex* block_index_, kernel_ChainstateManager* chainman_)`
`1053`	`1065`	`{`
`1054`		`- auto block_index{cast_block_index(block_index_)};`
	`1066`	`+ const auto block_index{cast_const_block_index(block_index_)};`
`1055`	`1067`	`auto chainman{cast_chainstate_manager(chainman_)};`
`1056`	`1068`
`1057`	`1069`	`auto next_block_index{WITH_LOCK(::cs_main, return chainman->ActiveChain().Next(block_index))};`
`@@ -1063,9 +1075,9 @@ kernel_BlockIndex* kernel_get_next_block_index(const kernel_Context* context_, k`
`1063`	`1075`	`return reinterpret_cast<kernel_BlockIndex*>(next_block_index);`
`1064`	`1076`	`}`
`1065`	`1077`
`1066`		`-kernel_BlockIndex* kernel_get_previous_block_index(kernel_BlockIndex* block_index_)`
	`1078`	`+kernel_BlockIndex* kernel_get_previous_block_index(const kernel_BlockIndex* block_index_)`
`1067`	`1079`	`{`
`1068`		`- CBlockIndex* block_index{cast_block_index(block_index_)};`
	`1080`	`+ const CBlockIndex* block_index{cast_const_block_index(block_index_)};`
`1069`	`1081`
`1070`	`1082`	`if (!block_index->pprev) {`
`1071`	`1083`	`LogTrace(BCLog::KERNEL, "The block index is the genesis, it has no previous.\n");`
`@@ -1077,10 +1089,10 @@ kernel_BlockIndex* kernel_get_previous_block_index(kernel_BlockIndex* block_inde`
`1077`	`1089`
`1078`	`1090`	`kernel_Block* kernel_read_block_from_disk(const kernel_Context* context_,`
`1079`	`1091`	`kernel_ChainstateManager* chainman_,`
`1080`		`- kernel_BlockIndex* block_index_)`
	`1092`	`+ const kernel_BlockIndex* block_index_)`
`1081`	`1093`	`{`
`1082`	`1094`	`auto chainman{cast_chainstate_manager(chainman_)};`
`1083`		`- CBlockIndex* block_index{cast_block_index(block_index_)};`
	`1095`	`+ const CBlockIndex* block_index{cast_const_block_index(block_index_)};`
`1084`	`1096`
`1085`	`1097`	`auto block{new std::shared_ptr<CBlock>(new CBlock{})};`
`1086`	`1098`	`if (!chainman->m_blockman.ReadBlockFromDisk(*block, block_index)) {`
`@@ -1092,10 +1104,10 @@ kernel_Block* kernel_read_block_from_disk(const kernel_Context* context_,`
`1092`	`1104`
`1093`	`1105`	`kernel_BlockUndo* kernel_read_block_undo_from_disk(const kernel_Context* context_,`
`1094`	`1106`	`kernel_ChainstateManager* chainman_,`
`1095`		`- kernel_BlockIndex* block_index_)`
	`1107`	`+ const kernel_BlockIndex* block_index_)`
`1096`	`1108`	`{`
`1097`	`1109`	`auto chainman{cast_chainstate_manager(chainman_)};`
`1098`		`- auto block_index{cast_block_index(block_index_)};`
	`1110`	`+ const auto block_index{cast_const_block_index(block_index_)};`
`1099`	`1111`
`1100`	`1112`	`if (block_index->nHeight < 1) {`
`1101`	`1113`	`LogError("The genesis block does not have undo data.\n");`
`@@ -1115,30 +1127,30 @@ void kernel_block_index_destroy(kernel_BlockIndex* block_index)`
`1115`	`1127`	`return;`
`1116`	`1128`	`}`
`1117`	`1129`
`1118`		`-uint64_t kernel_block_undo_size(kernel_BlockUndo* block_undo_)`
	`1130`	`+uint64_t kernel_block_undo_size(const kernel_BlockUndo* block_undo_)`
`1119`	`1131`	`{`
`1120`		`- auto block_undo{cast_block_undo(block_undo_)};`
	`1132`	`+ const auto block_undo{cast_const_block_undo(block_undo_)};`
`1121`	`1133`	`return block_undo->vtxundo.size();`
`1122`	`1134`	`}`
`1123`	`1135`
`1124`	`1136`	`void kernel_block_undo_destroy(kernel_BlockUndo* block_undo)`
`1125`	`1137`	`{`
`1126`	`1138`	`if (block_undo) {`
`1127`		`- delete cast_block_undo(block_undo);`
	`1139`	`+ delete cast_const_block_undo(block_undo);`
`1128`	`1140`	`}`
`1129`	`1141`	`}`
`1130`	`1142`
`1131`		`-uint64_t kernel_get_transaction_undo_size(kernel_BlockUndo* block_undo_, uint64_t transaction_undo_index)`
	`1143`	`+uint64_t kernel_get_transaction_undo_size(const kernel_BlockUndo* block_undo_, uint64_t transaction_undo_index)`
`1132`	`1144`	`{`
`1133`		`- auto block_undo{cast_block_undo(block_undo_)};`
	`1145`	`+ const auto block_undo{cast_const_block_undo(block_undo_)};`
`1134`	`1146`	`return block_undo->vtxundo[transaction_undo_index].vprevout.size();`
`1135`	`1147`	`}`
`1136`	`1148`
`1137`		`-kernel_TransactionOutput* kernel_get_undo_output_by_index(kernel_BlockUndo* block_undo_,`
	`1149`	`+kernel_TransactionOutput* kernel_get_undo_output_by_index(const kernel_BlockUndo* block_undo_,`
`1138`	`1150`	`uint64_t transaction_undo_index,`
`1139`	`1151`	`uint64_t output_index)`
`1140`	`1152`	`{`
`1141`		`- auto block_undo{cast_block_undo(block_undo_)};`
	`1153`	`+ const auto block_undo{cast_const_block_undo(block_undo_)};`
`1142`	`1154`
`1143`	`1155`	`if (transaction_undo_index >= block_undo->vtxundo.size()) {`
`1144`	`1156`	`LogInfo("transaction undo index is out of bounds.\n");`
`@@ -1156,15 +1168,15 @@ kernel_TransactionOutput* kernel_get_undo_output_by_index(kernel_BlockUndo* bloc`
`1156`	`1168`	`return reinterpret_cast<kernel_TransactionOutput*>(prevout);`
`1157`	`1169`	`}`
`1158`	`1170`
`1159`		`-int32_t kernel_block_index_get_height(kernel_BlockIndex* block_index_)`
	`1171`	`+int32_t kernel_block_index_get_height(const kernel_BlockIndex* block_index_)`
`1160`	`1172`	`{`
`1161`		`- auto block_index{cast_block_index(block_index_)};`
	`1173`	`+ auto block_index{cast_const_block_index(block_index_)};`
`1162`	`1174`	`return block_index->nHeight;`
`1163`	`1175`	`}`
`1164`	`1176`
`1165`		`-kernel_BlockHash* kernel_block_index_get_block_hash(kernel_BlockIndex* block_index_)`
	`1177`	`+kernel_BlockHash* kernel_block_index_get_block_hash(const kernel_BlockIndex* block_index_)`
`1166`	`1178`	`{`
`1167`		`- auto block_index{cast_block_index(block_index_)};`
	`1179`	`+ auto block_index{cast_const_block_index(block_index_)};`
`1168`	`1180`	`if (block_index->phashBlock == nullptr) {`
`1169`	`1181`	`return nullptr;`
`1170`	`1182`	`}`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ class KernelNotifications`
`173`	`173`	`{`
`174`	`174`	`private:`
`175`	`175`	`struct Deleter {`
`176`		`- void operator()(const kernel_Notifications* ptr) const`
	`176`	`+ void operator()(kernel_Notifications* ptr) const`
`177`	`177`	`{`
`178`	`178`	`kernel_notifications_destroy(ptr);`
`179`	`179`	`}`
`@@ -201,7 +201,7 @@ class KernelNotifications`
`201`	`201`	`};`
`202`	`202`	`}`
`203`	`203`
`204`		`- std::unique_ptr<const kernel_Notifications, Deleter> m_notifications;`
	`204`	`+ std::unique_ptr<kernel_Notifications, Deleter> m_notifications;`
`205`	`205`
`206`	`206`	`public:`
`207`	`207`	`KernelNotifications() : m_notifications{kernel_notifications_create(MakeCallbacks())} {}`