Merge commit 'cc50e310686f44fd56b27ddf6839f0ffc2cb6a02'

Author: stringintech

depend/bitcoin/src/kernel/bitcoinkernel.cpp

@@ -470,6 +470,7 @@ struct btck_Chain : Handle<btck_Chain, CChain> {};
 struct btck_BlockSpentOutputs : Handle<btck_BlockSpentOutputs, std::shared_ptr<CBlockUndo>> {};
 struct btck_TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, CTxUndo> {};
 struct btck_Coin : Handle<btck_Coin, Coin> {};
+struct btck_BlockHash : Handle<btck_BlockHash, uint256> {};
 
 btck_Transaction* btck_transaction_create(const void* raw_transaction, size_t raw_transaction_len)
 {
@@ -889,9 +890,8 @@ btck_ChainstateManager* btck_chainstate_manager_create(
 
 const btck_BlockTreeEntry* btck_chainstate_manager_get_block_tree_entry_by_hash(const btck_ChainstateManager* chainman, const btck_BlockHash* block_hash)
 {
-    auto hash = uint256{std::span<const unsigned char>{(*block_hash).hash, 32}};
     auto block_index = WITH_LOCK(btck_ChainstateManager::get(chainman).m_chainman->GetMutex(),
-                                 return btck_ChainstateManager::get(chainman).m_chainman->m_blockman.LookupBlockIndex(hash));
+                                 return btck_ChainstateManager::get(chainman).m_chainman->m_blockman.LookupBlockIndex(btck_BlockHash::get(block_hash)));
     if (!block_index) {
         LogDebug(BCLog::KERNEL, "A block with the given hash is not indexed.");
         return nullptr;
@@ -978,10 +978,7 @@ int btck_block_to_bytes(const btck_Block* block, btck_WriteBytes writer, void* u
 
 btck_BlockHash* btck_block_get_hash(const btck_Block* block)
 {
-    auto hash{btck_Block::get(block)->GetHash()};
-    auto block_hash = new btck_BlockHash{};
-    std::memcpy(block_hash->hash, hash.begin(), sizeof(hash));
-    return block_hash;
+    return btck_BlockHash::create(btck_Block::get(block)->GetHash());
 }
 
 void btck_block_destroy(btck_Block* block)
@@ -1009,9 +1006,22 @@ btck_BlockHash* btck_block_tree_entry_get_block_hash(const btck_BlockTreeEntry*
     if (btck_BlockTreeEntry::get(entry).phashBlock == nullptr) {
         return nullptr;
     }
-    auto block_hash = new btck_BlockHash{};
-    std::memcpy(block_hash->hash, btck_BlockTreeEntry::get(entry).phashBlock->begin(), sizeof(*btck_BlockTreeEntry::get(entry).phashBlock));
-    return block_hash;
+    return btck_BlockHash::create(btck_BlockTreeEntry::get(entry).GetBlockHash());
+}
+
+btck_BlockHash* btck_block_hash_create(const unsigned char block_hash[32])
+{
+    return btck_BlockHash::create(std::span<const unsigned char>{block_hash, 32});
+}
+
+btck_BlockHash* btck_block_hash_copy(const btck_BlockHash* block_hash)
+{
+    return btck_BlockHash::copy(block_hash);
+}
+
+void btck_block_hash_to_bytes(const btck_BlockHash* block_hash, unsigned char output[32])
+{
+    std::memcpy(output, btck_BlockHash::get(block_hash).begin(), 32);
 }
 
 void btck_block_hash_destroy(btck_BlockHash* hash)

depend/bitcoin/src/kernel/bitcoinkernel.h

@@ -249,6 +249,13 @@ typedef struct btck_TransactionSpentOutputs btck_TransactionSpentOutputs;
  */
 typedef struct btck_Coin btck_Coin;
 
+/**
+ * Opaque data structure for holding a block hash.
+ *
+ * This is a type-safe identifier for a block.
+ */
+typedef struct btck_BlockHash btck_BlockHash;
+
 /** Current sync state passed to tip changed callbacks. */
 typedef uint8_t btck_SynchronizationState;
 #define btck_SynchronizationState_INIT_REINDEX ((btck_SynchronizationState)(0))
@@ -426,13 +433,6 @@ typedef uint8_t btck_ChainType;
 #define btck_ChainType_SIGNET ((btck_ChainType)(3))
 #define btck_ChainType_REGTEST ((btck_ChainType)(4))
 
-/**
- * A type-safe block identifier.
- */
-typedef struct {
-    unsigned char hash[32];
-} btck_BlockHash;
-
 /** @name Transaction
  * Functions for working with transactions.
  */
@@ -853,6 +853,15 @@ BITCOINKERNEL_API const btck_BlockTreeEntry* BITCOINKERNEL_WARN_UNUSED_RESULT bt
 BITCOINKERNEL_API int32_t BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_height(
     const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
 
+/**
+ * @brief Return the block hash associated with a block tree entry.
+ *
+ * @param[in] block_tree_entry Non-null.
+ * @return                     The block hash.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_hash(
+    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+
 ///@}
 
 /** @name ChainstateManagerOptions
@@ -1087,7 +1096,7 @@ BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_ge
  * @param[in] writer    Non-null, callback to a write bytes function.
  * @param[in] user_data Holds a user-defined opaque structure that will be
  *                      passed back through the writer callback.
- * @return              True on success.
+ * @return              0 on success.
  */
 BITCOINKERNEL_API int btck_block_to_bytes(
     const btck_Block* block,
@@ -1336,13 +1345,28 @@ BITCOINKERNEL_API void btck_coin_destroy(btck_Coin* coin);
 ///@{
 
 /**
- * @brief Return the block hash associated with a block tree entry.
+ * @brief Create a block hash from its raw data.
+ */
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_create(
+    const unsigned char block_hash[32]) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Copy a block hash.
  *
- * @param[in] block_tree_entry Non-null.
- * @return                     The block hash.
+ * @param[in] block_hash Non-null.
+ * @return               The copied block hash.
  */
-BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_tree_entry_get_block_hash(
-    const btck_BlockTreeEntry* block_tree_entry) BITCOINKERNEL_ARG_NONNULL(1);
+BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_hash_copy(
+    const btck_BlockHash* block_hash) BITCOINKERNEL_ARG_NONNULL(1);
+
+/**
+ * @brief Serializes the block hash to bytes.
+ *
+ * @param[in] block_hash     Non-null.
+ * @param[in] output         The serialized block hash.
+ */
+BITCOINKERNEL_API void btck_block_hash_to_bytes(
+    const btck_BlockHash* block_hash, unsigned char output[32]) BITCOINKERNEL_ARG_NONNULL(1, 2);
 
 /**
  * Destroy the block hash.

depend/bitcoin/src/kernel/bitcoinkernel_wrapper.h

@@ -7,6 +7,7 @@
 
 #include <kernel/bitcoinkernel.h>
 
+#include <array>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -473,7 +474,7 @@ class TransactionApi
 
     auto Outputs() const
     {
-        return Range<Transaction, &TransactionApi::CountOutputs, &TransactionApi::GetOutput>{*static_cast<const Derived*>(this)};
+        return Range<Derived, &TransactionApi<Derived>::CountOutputs, &TransactionApi<Derived>::GetOutput>{*static_cast<const Derived*>(this)};
     }
 
     std::vector<std::byte> ToBytes() const
@@ -527,10 +528,20 @@ bool ScriptPubkeyApi<Derived>::Verify(int64_t amount,
     return result == 1;
 }
 
-struct BlockHashDeleter {
-    void operator()(btck_BlockHash* ptr) const
+class BlockHash : public Handle<btck_BlockHash, btck_block_hash_copy, btck_block_hash_destroy>
+{
+public:
+    explicit BlockHash(const std::array<std::byte, 32>& hash)
+        : Handle{btck_block_hash_create(reinterpret_cast<const unsigned char*>(hash.data()))} {}
+
+    explicit BlockHash(btck_BlockHash* hash)
+        : Handle{hash} {}
+
+    std::array<std::byte, 32> Bytes() const
     {
-        btck_block_hash_destroy(ptr);
+        std::array<std::byte, 32> hash;
+        btck_block_hash_to_bytes(get(), reinterpret_cast<unsigned char*>(hash.data()));
+        return hash;
     }
 };
 
@@ -559,9 +570,9 @@ class Block : public Handle<btck_Block, btck_block_copy, btck_block_destroy>
         return Range<Block, &Block::CountTransactions, &Block::GetTransaction>{*this};
     }
 
-    std::unique_ptr<btck_BlockHash, BlockHashDeleter> GetHash() const
+    BlockHash GetHash() const
     {
-        return std::unique_ptr<btck_BlockHash, BlockHashDeleter>(btck_block_get_hash(get()));
+        return BlockHash{btck_block_get_hash(get())};
     }
 
     std::vector<std::byte> ToBytes() const
@@ -631,9 +642,9 @@ class BlockTreeEntry : public View<btck_BlockTreeEntry>
         return btck_block_tree_entry_get_height(get());
     }
 
-    std::unique_ptr<btck_BlockHash, BlockHashDeleter> GetHash() const
+    BlockHash GetHash() const
     {
-        return std::unique_ptr<btck_BlockHash, BlockHashDeleter>(btck_block_tree_entry_get_block_hash(get()));
+        return BlockHash{btck_block_tree_entry_get_block_hash(get())};
     }
 
     friend class ChainMan;
@@ -761,6 +772,10 @@ class Context : public Handle<btck_Context, btck_context_copy, btck_context_dest
     Context()
         : Handle{check(btck_context_create(ContextOptions{}.get()))} {}
 
+    bool interrupt() {
+        return btck_context_interrupt(get()) == 0;
+    }
+
     friend class ChainstateManagerOptions;
 };
 
@@ -848,7 +863,7 @@ class CoinApi
 public:
     uint32_t GetConfirmationHeight() const { return btck_coin_confirmation_height(impl()); }
 
-    bool IsCoinbase() const { return btck_coin_is_coinbase(impl()); }
+    bool IsCoinbase() const { return btck_coin_is_coinbase(impl()) == 1; }
 
     TransactionOutputView GetOutput() const
     {
@@ -866,6 +881,8 @@ class Coin : Handle<btck_Coin, btck_coin_copy, btck_coin_destroy>, public CoinAp
 {
 public:
     Coin(btck_Coin* coin) : Handle{check(coin)} {}
+
+    Coin(const CoinView& view) : Handle{view} {}
 };
 
 template <typename Derived>
@@ -908,6 +925,8 @@ class TransactionSpentOutputs : Handle<btck_TransactionSpentOutputs, btck_transa
 {
 public:
     TransactionSpentOutputs(btck_TransactionSpentOutputs* transaction_spent_outputs) : Handle{check(transaction_spent_outputs)} {}
+
+    TransactionSpentOutputs(const TransactionSpentOutputsView& view) : Handle{view} {}
 };
 
 class BlockSpentOutputs : Handle<btck_BlockSpentOutputs, btck_block_spent_outputs_copy, btck_block_spent_outputs_destroy>
@@ -969,12 +988,12 @@ class ChainMan : UniqueHandle<btck_ChainstateManager, btck_chainstate_manager_de
         return ChainView{btck_chainstate_manager_get_active_chain(get())};
     }
 
-    BlockTreeEntry GetBlockTreeEntry(btck_BlockHash* block_hash) const
+    BlockTreeEntry GetBlockTreeEntry(const btck_BlockHash* block_hash) const
     {
         return btck_chainstate_manager_get_block_tree_entry_by_hash(get(), block_hash);
     }
 
-    std::optional<Block> ReadBlock(BlockTreeEntry& entry) const
+    std::optional<Block> ReadBlock(const BlockTreeEntry& entry) const
     {
         auto block{btck_block_read(get(), entry.get())};
         if (!block) return std::nullopt;