Squashed 'depend/bitcoin/' changes from 35fced5df7..fdc9f98cae

fdc9f98cae kernel: Fix bitcoin-chainstate for windows
23d43c4e79 kernel: Add Purpose section to header documentation
7924a86ccf kernel: Allowing reducing exports
98234b1443 kernel: Add pure kernel bitcoin-chainstate
bcacaf9f7d kernel: Add functions to get the block hash from a block
69d457909f kernel: Add block index utility functions to C header
15ab14d841 kernel: Add function to read block undo data from disk to C header
f156e36930 kernel: Add functions to read block from disk to C header
ec46b7d770 kernel: Add function for copying block data to C header
91d9e14286 kernel: Add functions for the block validation state to C header
41b77072d3 kernel: Add validation interface to C header
96bdab979e kernel: Add interrupt function to C header
2989cb0fa4 kernel: Add import blocks function to C header
1063846417 kernel: Add chainstate load options for in-memory dbs in C header
809e0c2441 kernel: Add options for reindexing in C header
a1b6632702 kernel: Add block validation to C header
35d1e2dfbf kernel: Add chainstate loading when instantiating a ChainstateManager
824a5d549e kernel: Add chainstate manager option for setting worker threads
c3bb19aaf4 kernel: Add chainstate manager object to C header
0d2cbf47d6 kernel: Add notifications context option to C header
df43fd0151 kernel: Add chain params context option to C header
02e0874a91 kernel: Add kernel library context object
de9bc8e47b kernel: Add logging to kernel library C header
a771ea573b kernel: Introduce initial kernel C header API
REVERT: 35fced5df7 kernel: Fix bitcoin-chainstate for windows
REVERT: c164264fd8 kernel: Add Purpose section to header documentation
REVERT: 9096c35c05 kernel: Allowing reducing exports
REVERT: 6d0d4b2507 kernel: Add pure kernel bitcoin-chainstate
REVERT: ccd85f0333 kernel: Add functions to get the block hash from a block
REVERT: 925f21c37b kernel: Add block index utility functions to C header
REVERT: b7441841c9 kernel: Add function to read block undo data from disk to C header
REVERT: bc0e6f098e kernel: Add functions to read block from disk to C header
REVERT: 5120302f96 kernel: Add function for copying block data to C header
REVERT: 718ccee732 kernel: Add functions for the block validation state to C header
REVERT: eb363ab30e kernel: Add validation interface to C header
REVERT: 246886c6ea kernel: Add interrupt function to C header
REVERT: f3b34ca457 kernel: Add import blocks function to C header
REVERT: fe08857d52 kernel: Add chainstate load options for in-memory dbs in C header
REVERT: f93f171e01 kernel: Add options for reindexing in C header
REVERT: dca7b4c26e kernel: Add block validation to C header
REVERT: f031e9ce03 kernel: Add chainstate loading when instantiating a ChainstateManager
REVERT: 3cb99f73ec kernel: Add chainstate manager option for setting worker threads
REVERT: 9454ad8512 kernel: Add chainstate manager object to C header
REVERT: 3bead9ebdd kernel: Add notifications context option to C header
REVERT: dda805dfb6 kernel: Add chain params context option to C header
REVERT: ea5334925d kernel: Add kernel library context object
REVERT: 36fafbaef9 kernel: Add logging to kernel library C header
REVERT: d28eef5cf2 kernel: Introduce initial kernel C header API

git-subtree-dir: depend/bitcoin
git-subtree-split: fdc9f98caeb9e77f20e55c4446a3c23d2da51011

Author: stringintech

src/bitcoin-chainstate.cpp

@@ -55,47 +55,47 @@ class TestValidationInterface : public ValidationInterface<TestValidationInterfa
 
     void BlockChecked(const UnownedBlock block, const BlockValidationState state) override
     {
-        auto mode{state.ValidationMode()};
+        auto mode{state.GetValidationMode()};
         switch (mode) {
-        case btck_ValidationMode::btck_VALIDATION_STATE_VALID: {
+        case ValidationMode::VALID: {
             std::cout << "Valid block" << std::endl;
             return;
         }
-        case btck_ValidationMode::btck_VALIDATION_STATE_INVALID: {
+        case ValidationMode::INVALID: {
             std::cout << "Invalid block: ";
-            auto result{state.BlockValidationResult()};
+            auto result{state.GetBlockValidationResult()};
             switch (result) {
-            case btck_BlockValidationResult::btck_BLOCK_RESULT_UNSET:
+            case BlockValidationResult::UNSET:
                 std::cout << "initial value. Block has not yet been rejected" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_HEADER_LOW_WORK:
+            case BlockValidationResult::HEADER_LOW_WORK:
                 std::cout << "the block header may be on a too-little-work chain" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_CONSENSUS:
+            case BlockValidationResult::CONSENSUS:
                 std::cout << "invalid by consensus rules (excluding any below reasons)" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_CACHED_INVALID:
+            case BlockValidationResult::CACHED_INVALID:
                 std::cout << "this block was cached as being invalid and we didn't store the reason why" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_INVALID_HEADER:
+            case BlockValidationResult::INVALID_HEADER:
                 std::cout << "invalid proof of work or time too old" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_MUTATED:
+            case BlockValidationResult::MUTATED:
                 std::cout << "the block's data didn't match the data committed to by the PoW" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_MISSING_PREV:
+            case BlockValidationResult::MISSING_PREV:
                 std::cout << "We don't have the previous block the checked one is built on" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_INVALID_PREV:
+            case BlockValidationResult::INVALID_PREV:
                 std::cout << "A block this one builds on is invalid" << std::endl;
                 break;
-            case btck_BlockValidationResult::btck_BLOCK_TIME_FUTURE:
+            case BlockValidationResult::TIME_FUTURE:
                 std::cout << "block timestamp was > 2 hours in the future (or our clock is bad)" << std::endl;
                 break;
             }
             return;
         }
-        case btck_ValidationMode::btck_VALIDATION_STATE_ERROR: {
+        case ValidationMode::INTERNAL_ERROR: {
             std::cout << "Internal error" << std::endl;
             return;
         }
@@ -106,7 +106,7 @@ class TestValidationInterface : public ValidationInterface<TestValidationInterfa
 class TestKernelNotifications : public KernelNotifications<TestKernelNotifications>
 {
 public:
-    void BlockTipHandler(btck_SynchronizationState, const BlockTreeEntry, double) override
+    void BlockTipHandler(SynchronizationState, const BlockTreeEntry, double) override
     {
         std::cout << "Block tip changed" << std::endl;
     }
@@ -116,14 +116,14 @@ class TestKernelNotifications : public KernelNotifications<TestKernelNotificatio
         std::cout << "Made progress: " << title << " " << progress_percent << "%" << std::endl;
     }
 
-    void WarningSetHandler(btck_Warning warning, std::string_view message) override
+    void WarningSetHandler(Warning warning, std::string_view message) override
     {
         std::cout << message << std::endl;
     }
 
-    void WarningUnsetHandler(btck_Warning warning) override
+    void WarningUnsetHandler(Warning warning) override
     {
-        std::cout << "Warning unset: " << warning << std::endl;
+        std::cout << "Warning unset: " << static_cast<std::underlying_type_t<Warning>>(warning) << std::endl;
     }
 
     void FlushErrorHandler(std::string_view error) override
@@ -179,7 +179,7 @@ int main(int argc, char* argv[])
     Logger logger{std::make_unique<KernelLog>(KernelLog{}), logging_options};
 
     ContextOptions options{};
-    ChainParams params{btck_ChainType::btck_CHAIN_TYPE_MAINNET};
+    ChainParams params{ChainType::MAINNET};
     options.SetChainParams(params);
 
     TestKernelNotifications notifications{};

src/kernel/bitcoinkernel.cpp

@@ -64,12 +64,6 @@ struct btck_BlockTreeEntry {
 
 namespace {
 
-/** Check that all specified flags are part of the libbitcoinkernel interface. */
-bool verify_flags(unsigned int flags)
-{
-    return (flags & ~(btck_SCRIPT_FLAGS_VERIFY_ALL)) == 0;
-}
-
 bool is_valid_flag_combination(unsigned int flags)
 {
     if (flags & SCRIPT_VERIFY_CLEANSTACK && ~flags & (SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS)) return false;
@@ -105,71 +99,71 @@ class WriterStream
     }
 };
 
-BCLog::Level get_bclog_level(const btck_LogLevel level)
+BCLog::Level get_bclog_level(btck_LogLevel level)
 {
     switch (level) {
-    case btck_LogLevel::btck_LOG_INFO: {
+    case btck_LogLevel_INFO: {
         return BCLog::Level::Info;
     }
-    case btck_LogLevel::btck_LOG_DEBUG: {
+    case btck_LogLevel_DEBUG: {
         return BCLog::Level::Debug;
     }
-    case btck_LogLevel::btck_LOG_TRACE: {
+    case btck_LogLevel_TRACE: {
         return BCLog::Level::Trace;
     }
-    } // no default case, so the compiler can warn about missing cases
+    }
     assert(false);
 }
 
-BCLog::LogFlags get_bclog_flag(const btck_LogCategory category)
+BCLog::LogFlags get_bclog_flag(btck_LogCategory category)
 {
     switch (category) {
-    case btck_LogCategory::btck_LOG_BENCH: {
+    case btck_LogCategory_BENCH: {
         return BCLog::LogFlags::BENCH;
     }
-    case btck_LogCategory::btck_LOG_BLOCKSTORAGE: {
+    case btck_LogCategory_BLOCKSTORAGE: {
         return BCLog::LogFlags::BLOCKSTORAGE;
     }
-    case btck_LogCategory::btck_LOG_COINDB: {
+    case btck_LogCategory_COINDB: {
         return BCLog::LogFlags::COINDB;
     }
-    case btck_LogCategory::btck_LOG_LEVELDB: {
+    case btck_LogCategory_LEVELDB: {
         return BCLog::LogFlags::LEVELDB;
     }
-    case btck_LogCategory::btck_LOG_MEMPOOL: {
+    case btck_LogCategory_MEMPOOL: {
         return BCLog::LogFlags::MEMPOOL;
     }
-    case btck_LogCategory::btck_LOG_PRUNE: {
+    case btck_LogCategory_PRUNE: {
         return BCLog::LogFlags::PRUNE;
     }
-    case btck_LogCategory::btck_LOG_RAND: {
+    case btck_LogCategory_RAND: {
         return BCLog::LogFlags::RAND;
     }
-    case btck_LogCategory::btck_LOG_REINDEX: {
+    case btck_LogCategory_REINDEX: {
         return BCLog::LogFlags::REINDEX;
     }
-    case btck_LogCategory::btck_LOG_VALIDATION: {
+    case btck_LogCategory_VALIDATION: {
         return BCLog::LogFlags::VALIDATION;
     }
-    case btck_LogCategory::btck_LOG_KERNEL: {
+    case btck_LogCategory_KERNEL: {
         return BCLog::LogFlags::KERNEL;
     }
-    case btck_LogCategory::btck_LOG_ALL: {
+    case btck_LogCategory_ALL: {
         return BCLog::LogFlags::ALL;
     }
-    } // no default case, so the compiler can warn about missing cases
+    }
     assert(false);
 }
 
 btck_SynchronizationState cast_state(SynchronizationState state)
 {
     switch (state) {
     case SynchronizationState::INIT_REINDEX:
-        return btck_SynchronizationState::btck_INIT_REINDEX;
+        return btck_SynchronizationState_INIT_REINDEX;
     case SynchronizationState::INIT_DOWNLOAD:
-        return btck_SynchronizationState::btck_INIT_DOWNLOAD;
+        return btck_SynchronizationState_INIT_DOWNLOAD;
     case SynchronizationState::POST_INIT:
-        return btck_SynchronizationState::btck_POST_INIT;
+        return btck_SynchronizationState_POST_INIT;
     } // no default case, so the compiler can warn about missing cases
     assert(false);
 }
@@ -178,9 +172,9 @@ btck_Warning cast_btck_warning(kernel::Warning warning)
 {
     switch (warning) {
     case kernel::Warning::UNKNOWN_NEW_RULES_ACTIVATED:
-        return btck_Warning::btck_UNKNOWN_NEW_RULES_ACTIVATED;
+        return btck_Warning_UNKNOWN_NEW_RULES_ACTIVATED;
     case kernel::Warning::LARGE_WORK_INVALID_CHAIN:
-        return btck_Warning::btck_LARGE_WORK_INVALID_CHAIN;
+        return btck_Warning_LARGE_WORK_INVALID_CHAIN;
     } // no default case, so the compiler can warn about missing cases
     assert(false);
 }
@@ -521,23 +515,21 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
                           const btck_Transaction* tx_to,
                           const btck_TransactionOutput** spent_outputs_, size_t spent_outputs_len,
                           const unsigned int input_index,
-                          const unsigned int flags,
+                          const btck_ScriptVerificationFlags flags,
                           btck_ScriptVerifyStatus* status)
 {
     const CAmount amount{amount_};
 
-    if (!verify_flags(flags)) {
-        if (status) *status = btck_SCRIPT_VERIFY_ERROR_INVALID_FLAGS;
-        return 0;
-    }
+    // Assert that all specified flags are part of the interface before continuing
+    assert((flags & ~btck_ScriptVerificationFlags_ALL) == 0);
 
     if (!is_valid_flag_combination(flags)) {
-        if (status) *status = btck_SCRIPT_VERIFY_ERROR_INVALID_FLAGS_COMBINATION;
+        if (status) *status = btck_ScriptVerifyStatus_ERROR_INVALID_FLAGS_COMBINATION;
         return 0;
     }
 
-    if (flags & btck_SCRIPT_FLAGS_VERIFY_TAPROOT && spent_outputs_ == nullptr) {
-        if (status) *status = btck_SCRIPT_VERIFY_ERROR_SPENT_OUTPUTS_REQUIRED;
+    if (flags & btck_ScriptVerificationFlags_TAPROOT  && spent_outputs_ == nullptr) {
+        if (status) *status = btck_ScriptVerifyStatus_ERROR_SPENT_OUTPUTS_REQUIRED;
         return 0;
     }
 
@@ -555,7 +547,7 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
     assert(input_index < tx.vin.size());
     PrecomputedTransactionData txdata{tx};
 
-    if (spent_outputs_ != nullptr && flags & btck_SCRIPT_FLAGS_VERIFY_TAPROOT) {
+    if (spent_outputs_ != nullptr && flags & btck_ScriptVerificationFlags_TAPROOT) {
         txdata.Init(tx, std::move(spent_outputs));
     }
 
@@ -568,21 +560,21 @@ int btck_script_pubkey_verify(const btck_ScriptPubkey* script_pubkey,
     return result ? 1 : 0;
 }
 
-void btck_logging_set_level_category(const btck_LogCategory category, const btck_LogLevel level)
+void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
 {
-    if (category == btck_LogCategory::btck_LOG_ALL) {
+    if (category == btck_LogCategory_ALL) {
         LogInstance().SetLogLevel(get_bclog_level(level));
     }
 
     LogInstance().AddCategoryLogLevel(get_bclog_flag(category), get_bclog_level(level));
 }
 
-void btck_logging_enable_category(const btck_LogCategory category)
+void btck_logging_enable_category(btck_LogCategory category)
 {
     LogInstance().EnableCategory(get_bclog_flag(category));
 }
 
-void btck_logging_disable_category(const btck_LogCategory category)
+void btck_logging_disable_category(btck_LogCategory category)
 {
     LogInstance().DisableCategory(get_bclog_flag(category));
 }
@@ -643,22 +635,22 @@ void btck_logging_connection_destroy(btck_LoggingConnection* connection)
 btck_ChainParameters* btck_chain_parameters_create(const btck_ChainType chain_type)
 {
     switch (chain_type) {
-    case btck_ChainType::btck_CHAIN_TYPE_MAINNET: {
+    case btck_ChainType_MAINNET: {
         return new btck_ChainParameters{CChainParams::Main()};
     }
-    case btck_ChainType::btck_CHAIN_TYPE_TESTNET: {
+    case btck_ChainType_TESTNET: {
         return new btck_ChainParameters{CChainParams::TestNet()};
     }
-    case btck_ChainType::btck_CHAIN_TYPE_TESTNET_4: {
+    case btck_ChainType_TESTNET_4: {
         return new btck_ChainParameters{CChainParams::TestNet4()};
     }
-    case btck_ChainType::btck_CHAIN_TYPE_SIGNET: {
+    case btck_ChainType_SIGNET: {
         return new btck_ChainParameters{CChainParams::SigNet({})};
     }
-    case btck_ChainType::btck_CHAIN_TYPE_REGTEST: {
+    case btck_ChainType_REGTEST: {
         return new btck_ChainParameters{CChainParams::RegTest({})};
     }
-    } // no default case, so the compiler can warn about missing cases
+    }
     assert(false);
 }
 
@@ -744,33 +736,33 @@ void btck_block_tree_entry_destroy(btck_BlockTreeEntry* block_tree_entry)
 btck_ValidationMode btck_block_validation_state_get_validation_mode(const btck_BlockValidationState* block_validation_state_)
 {
     auto& block_validation_state = *cast_block_validation_state(block_validation_state_);
-    if (block_validation_state.IsValid()) return btck_ValidationMode::btck_VALIDATION_STATE_VALID;
-    if (block_validation_state.IsInvalid()) return btck_ValidationMode::btck_VALIDATION_STATE_INVALID;
-    return btck_ValidationMode::btck_VALIDATION_STATE_ERROR;
+    if (block_validation_state.IsValid()) return btck_ValidationMode_VALID;
+    if (block_validation_state.IsInvalid()) return btck_ValidationMode_INVALID;
+    return btck_ValidationMode_INTERNAL_ERROR;
 }
 
 btck_BlockValidationResult btck_block_validation_state_get_block_validation_result(const btck_BlockValidationState* block_validation_state_)
 {
     auto& block_validation_state = *cast_block_validation_state(block_validation_state_);
     switch (block_validation_state.GetResult()) {
     case BlockValidationResult::BLOCK_RESULT_UNSET:
-        return btck_BlockValidationResult::btck_BLOCK_RESULT_UNSET;
+        return btck_BlockValidationResult_UNSET;
     case BlockValidationResult::BLOCK_CONSENSUS:
-        return btck_BlockValidationResult::btck_BLOCK_CONSENSUS;
+        return btck_BlockValidationResult_CONSENSUS;
     case BlockValidationResult::BLOCK_CACHED_INVALID:
-        return btck_BlockValidationResult::btck_BLOCK_CACHED_INVALID;
+        return btck_BlockValidationResult_CACHED_INVALID;
     case BlockValidationResult::BLOCK_INVALID_HEADER:
-        return btck_BlockValidationResult::btck_BLOCK_INVALID_HEADER;
+        return btck_BlockValidationResult_INVALID_HEADER;
     case BlockValidationResult::BLOCK_MUTATED:
-        return btck_BlockValidationResult::btck_BLOCK_MUTATED;
+        return btck_BlockValidationResult_MUTATED;
     case BlockValidationResult::BLOCK_MISSING_PREV:
-        return btck_BlockValidationResult::btck_BLOCK_MISSING_PREV;
+        return btck_BlockValidationResult_MISSING_PREV;
     case BlockValidationResult::BLOCK_INVALID_PREV:
-        return btck_BlockValidationResult::btck_BLOCK_INVALID_PREV;
+        return btck_BlockValidationResult_INVALID_PREV;
     case BlockValidationResult::BLOCK_TIME_FUTURE:
-        return btck_BlockValidationResult::btck_BLOCK_TIME_FUTURE;
+        return btck_BlockValidationResult_TIME_FUTURE;
     case BlockValidationResult::BLOCK_HEADER_LOW_WORK:
-        return btck_BlockValidationResult::btck_BLOCK_HEADER_LOW_WORK;
+        return btck_BlockValidationResult_HEADER_LOW_WORK;
     } // no default case, so the compiler can warn about missing cases
     assert(false);
 }