Add header handling

Author: TheCharlatan

src/core/block.rs

@@ -109,11 +109,13 @@ use std::{
 };
 
 use libbitcoinkernel_sys::{
-    btck_Block, btck_BlockHash, btck_BlockSpentOutputs, btck_Coin, btck_TransactionSpentOutputs,
-    btck_block_copy, btck_block_count_transactions, btck_block_create, btck_block_destroy,
-    btck_block_get_hash, btck_block_get_transaction_at, btck_block_hash_copy,
-    btck_block_hash_create, btck_block_hash_destroy, btck_block_hash_equals,
-    btck_block_hash_to_bytes, btck_block_spent_outputs_copy, btck_block_spent_outputs_count,
+    btck_Block, btck_BlockHash, btck_BlockHeader, btck_BlockSpentOutputs, btck_Coin,
+    btck_TransactionSpentOutputs, btck_block_copy, btck_block_count_transactions,
+    btck_block_create, btck_block_destroy, btck_block_get_hash, btck_block_get_header,
+    btck_block_get_transaction_at, btck_block_hash_copy, btck_block_hash_create,
+    btck_block_hash_destroy, btck_block_hash_equals, btck_block_hash_to_bytes,
+    btck_block_header_copy, btck_block_header_create, btck_block_header_destroy,
+    btck_block_header_get_hash, btck_block_spent_outputs_copy, btck_block_spent_outputs_count,
     btck_block_spent_outputs_destroy, btck_block_spent_outputs_get_transaction_spent_outputs_at,
     btck_block_to_bytes, btck_coin_confirmation_height, btck_coin_copy, btck_coin_destroy,
     btck_coin_get_output, btck_coin_is_coinbase, btck_transaction_spent_outputs_copy,
@@ -270,6 +272,15 @@ impl AsPtr<btck_BlockHash> for BlockHash {
     }
 }
 
+impl<'a> FromPtr<btck_BlockHash> for BlockHashRef<'a> {
+    unsafe fn from_ptr(ptr: *const btck_BlockHash) -> Self {
+        BlockHashRef {
+            inner: ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
 impl FromMutPtr<btck_BlockHash> for BlockHash {
     unsafe fn from_ptr(ptr: *mut btck_BlockHash) -> Self {
         BlockHash { inner: ptr }
@@ -377,15 +388,6 @@ impl<'a> AsPtr<btck_BlockHash> for BlockHashRef<'a> {
     }
 }
 
-impl<'a> FromPtr<btck_BlockHash> for BlockHashRef<'a> {
-    unsafe fn from_ptr(ptr: *const btck_BlockHash) -> Self {
-        BlockHashRef {
-            inner: ptr,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'a> BlockHashExt for BlockHashRef<'a> {}
 
 impl<'a> Clone for BlockHashRef<'a> {
@@ -420,6 +422,114 @@ impl<'a> Eq for BlockHashRef<'a> {}
 
 impl<'a> Copy for BlockHashRef<'a> {}
 
+/// Common operations for block headers, implemented by both owned and borrow types.
+pub trait BlockHeaderExt: AsPtr<btck_BlockHeader> {
+    /// Return the block hash of the header.
+    fn hash(&self) -> BlockHash {
+        unsafe { BlockHash::from_ptr(btck_block_header_get_hash(self.as_ptr())) }
+    }
+}
+
+/// A Bitcoin block header.
+///
+/// Block headers can be created from raw serialized data or retrieved from the
+/// chain or blocks.
+pub struct BlockHeader {
+    inner: *mut btck_BlockHeader,
+}
+
+unsafe impl Send for BlockHeader {}
+unsafe impl Sync for BlockHeader {}
+
+impl BlockHeader {
+    pub fn new(header_bytes: &[u8]) -> Result<Self, KernelError> {
+        let inner = unsafe {
+            btck_block_header_create(header_bytes.as_ptr() as *const c_void, header_bytes.len())
+        };
+
+        if inner.is_null() {
+            Err(KernelError::Internal(
+                "Failed to create header from bytes".to_string(),
+            ))
+        } else {
+            Ok(BlockHeader { inner })
+        }
+    }
+
+    pub fn as_ref(&self) -> BlockHeaderRef<'_> {
+        unsafe { BlockHeaderRef::from_ptr(self.inner as *const _) }
+    }
+}
+
+impl FromMutPtr<btck_BlockHeader> for BlockHeader {
+    unsafe fn from_ptr(ptr: *mut btck_BlockHeader) -> Self {
+        BlockHeader { inner: ptr }
+    }
+}
+
+impl AsPtr<btck_BlockHeader> for BlockHeader {
+    fn as_ptr(&self) -> *const btck_BlockHeader {
+        self.inner as *const _
+    }
+}
+
+impl BlockHeaderExt for BlockHeader {}
+
+impl Clone for BlockHeader {
+    fn clone(&self) -> Self {
+        BlockHeader {
+            inner: unsafe { btck_block_header_copy(self.inner) },
+        }
+    }
+}
+
+impl Drop for BlockHeader {
+    fn drop(&mut self) {
+        unsafe { btck_block_header_destroy(self.inner) }
+    }
+}
+
+pub struct BlockHeaderRef<'a> {
+    inner: *const btck_BlockHeader,
+    marker: PhantomData<&'a ()>,
+}
+
+unsafe impl<'a> Send for BlockHeaderRef<'a> {}
+unsafe impl<'a> Sync for BlockHeaderRef<'a> {}
+
+impl<'a> BlockHeaderRef<'a> {
+    pub fn to_owned(&self) -> BlockHeader {
+        BlockHeader {
+            inner: unsafe { btck_block_header_copy(self.inner) },
+        }
+    }
+}
+
+impl<'a> AsPtr<btck_BlockHeader> for BlockHeaderRef<'a> {
+    fn as_ptr(&self) -> *const btck_BlockHeader {
+        self.inner
+    }
+}
+
+impl<'a> FromPtr<btck_BlockHeader> for BlockHeaderRef<'a> {
+    unsafe fn from_ptr(ptr: *const btck_BlockHeader) -> Self {
+        BlockHeaderRef {
+            inner: ptr,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a> BlockHeaderExt for BlockHeaderRef<'a> {}
+
+impl<'a> Copy for BlockHeaderRef<'a> {}
+
+impl<'a> Clone for BlockHeaderRef<'a> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
 /// A block containing a header and transactions.
 ///
 /// Blocks are the fundamental units of the block chain, linking together
@@ -542,6 +652,10 @@ impl Block {
         unsafe { btck_block_count_transactions(self.inner) }
     }
 
+    pub fn header(&self) -> BlockHeader {
+        unsafe { BlockHeader::from_ptr(btck_block_get_header(self.inner)) }
+    }
+
     /// Returns a reference to the transaction at the specified index.
     ///
     /// # Arguments
@@ -1574,6 +1688,23 @@ mod tests {
 
     test_owned_trait_requirements!(test_block_requirements, Block, btck_Block);
 
+    test_owned_trait_requirements!(
+        test_block_header_requirements,
+        BlockHeader,
+        btck_BlockHeader
+    );
+    test_ref_trait_requirements!(
+        test_block_header_ref_requirements,
+        BlockHeaderRef<'static>,
+        btck_BlockHeader
+    );
+
+    test_owned_clone_and_send!(
+        test_block_header_clone_send,
+        Block::new(&read_block_data()[0]).unwrap().header(),
+        Block::new(&read_block_data()[1]).unwrap()
+    );
+
     test_owned_trait_requirements!(
         test_block_spent_outputs_requirements,
         BlockSpentOutputs,

src/core/block_tree_entry.rs

@@ -1,12 +1,13 @@
 use std::marker::PhantomData;
 
 use libbitcoinkernel_sys::{
-    btck_BlockTreeEntry, btck_block_tree_entry_get_block_hash, btck_block_tree_entry_get_height,
+    btck_BlockTreeEntry, btck_block_tree_entry_get_block_hash,
+    btck_block_tree_entry_get_block_header, btck_block_tree_entry_get_height,
     btck_block_tree_entry_get_previous,
 };
 
 use crate::{
-    core::block::BlockHashRef,
+    core::block::{BlockHashRef, BlockHeaderRef},
     ffi::sealed::{AsPtr, FromPtr},
     ChainstateManager,
 };
@@ -44,6 +45,10 @@ impl<'a> BlockTreeEntry<'a> {
         unsafe { btck_block_tree_entry_get_height(self.inner) }
     }
 
+    pub fn header(&self) -> BlockHeaderRef<'_> {
+        unsafe { BlockHeaderRef::from_ptr(btck_block_tree_entry_get_block_header(self.inner)) }
+    }
+
     /// Returns the current block hash associated with this BlockTreeEntry.
     pub fn block_hash(&self) -> BlockHashRef<'_> {
         let hash_ptr = unsafe { btck_block_tree_entry_get_block_hash(self.inner) };

src/notifications/types.rs

@@ -2,12 +2,14 @@ use std::marker::PhantomData;
 
 use libbitcoinkernel_sys::{
     btck_BlockValidationResult, btck_BlockValidationState, btck_SynchronizationState,
-    btck_ValidationMode, btck_Warning, btck_block_validation_state_get_block_validation_result,
+    btck_ValidationMode, btck_Warning, btck_block_validation_state_copy,
+    btck_block_validation_state_create, btck_block_validation_state_destroy,
+    btck_block_validation_state_get_block_validation_result,
     btck_block_validation_state_get_validation_mode,
 };
 
 use crate::{
-    ffi::sealed::{AsPtr, FromPtr},
+    ffi::sealed::{AsPtr, FromMutPtr, FromPtr},
     BTCK_BLOCK_VALIDATION_RESULT_CACHED_INVALID, BTCK_BLOCK_VALIDATION_RESULT_CONSENSUS,
     BTCK_BLOCK_VALIDATION_RESULT_HEADER_LOW_WORK, BTCK_BLOCK_VALIDATION_RESULT_INVALID_HEADER,
     BTCK_BLOCK_VALIDATION_RESULT_INVALID_PREV, BTCK_BLOCK_VALIDATION_RESULT_MISSING_PREV,
@@ -191,6 +193,49 @@ pub trait BlockValidationStateExt: AsPtr<btck_BlockValidationState> {
     }
 }
 
+pub struct BlockValidationState {
+    inner: *mut btck_BlockValidationState,
+}
+
+unsafe impl Send for BlockValidationState {}
+unsafe impl Sync for BlockValidationState {}
+
+impl BlockValidationState {
+    pub fn new() -> BlockValidationState {
+        BlockValidationState {
+            inner: unsafe { btck_block_validation_state_create() },
+        }
+    }
+}
+
+impl AsPtr<btck_BlockValidationState> for BlockValidationState {
+    fn as_ptr(&self) -> *const btck_BlockValidationState {
+        self.inner as *const _
+    }
+}
+
+impl FromMutPtr<btck_BlockValidationState> for BlockValidationState {
+    unsafe fn from_ptr(ptr: *mut btck_BlockValidationState) -> Self {
+        BlockValidationState { inner: ptr }
+    }
+}
+
+impl BlockValidationStateExt for BlockValidationState {}
+
+impl Clone for BlockValidationState {
+    fn clone(&self) -> Self {
+        BlockValidationState {
+            inner: unsafe { btck_block_validation_state_copy(self.inner) },
+        }
+    }
+}
+
+impl Drop for BlockValidationState {
+    fn drop(&mut self) {
+        unsafe { btck_block_validation_state_destroy(self.inner) }
+    }
+}
+
 pub struct BlockValidationStateRef<'a> {
     inner: *const btck_BlockValidationState,
     marker: PhantomData<&'a ()>,
@@ -228,10 +273,18 @@ impl<'a> BlockValidationStateExt for BlockValidationStateRef<'a> {}
 mod tests {
     use libbitcoinkernel_sys::btck_BlockValidationState;
 
-    use crate::ffi::test_utils::test_ref_trait_requirements;
+    use crate::{
+        ffi::test_utils::{test_owned_trait_requirements, test_ref_trait_requirements},
+        notifications::types::{BlockValidationState, BlockValidationStateRef},
+    };
 
     use super::*;
 
+    test_owned_trait_requirements!(
+        test_block_validation_state_requirements,
+        BlockValidationState,
+        btck_BlockValidationState
+    );
     test_ref_trait_requirements!(
         test_block_validation_state_ref_requirements,
         BlockValidationStateRef<'static>,

src/state/chainstate.rs

@@ -28,22 +28,26 @@
 use std::ffi::CString;
 
 use libbitcoinkernel_sys::{
-    btck_BlockHash, btck_ChainstateManager, btck_ChainstateManagerOptions, btck_block_read,
-    btck_block_spent_outputs_read, btck_chainstate_manager_create, btck_chainstate_manager_destroy,
-    btck_chainstate_manager_get_active_chain, btck_chainstate_manager_get_block_tree_entry_by_hash,
-    btck_chainstate_manager_import_blocks, btck_chainstate_manager_options_create,
-    btck_chainstate_manager_options_destroy, btck_chainstate_manager_options_set_wipe_dbs,
+    btck_BlockHash, btck_BlockValidationState, btck_ChainstateManager,
+    btck_ChainstateManagerOptions, btck_block_read, btck_block_spent_outputs_read,
+    btck_chainstate_manager_create, btck_chainstate_manager_destroy,
+    btck_chainstate_manager_get_active_chain, btck_chainstate_manager_get_best_entry,
+    btck_chainstate_manager_get_block_tree_entry_by_hash, btck_chainstate_manager_import_blocks,
+    btck_chainstate_manager_options_create, btck_chainstate_manager_options_destroy,
+    btck_chainstate_manager_options_set_wipe_dbs,
     btck_chainstate_manager_options_set_worker_threads_num,
     btck_chainstate_manager_options_update_block_tree_db_in_memory,
     btck_chainstate_manager_options_update_chainstate_db_in_memory,
-    btck_chainstate_manager_process_block,
+    btck_chainstate_manager_process_block, btck_chainstate_manager_process_block_header,
 };
 
 use crate::{
+    core::block::BlockHeader,
     ffi::{
         c_helpers,
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
+    notifications::types::BlockValidationState,
     Block, BlockHash, BlockSpentOutputs, BlockTreeEntry, KernelError,
 };
 
@@ -253,6 +257,18 @@ impl ChainstateManager {
         }
     }
 
+    pub fn process_header(&self, header: &BlockHeader) -> (bool, BlockValidationState) {
+        let state = BlockValidationState::new();
+        let accepted = unsafe {
+            btck_chainstate_manager_process_block_header(
+                self.inner,
+                header.as_ptr(),
+                state.as_ptr() as *mut btck_BlockValidationState,
+            )
+        };
+        (c_helpers::success(accepted), state)
+    }
+
     /// Initialize the chainstate manager and optionally trigger a reindex.
     ///
     /// This should be called after creating the chainstate manager to complete
@@ -347,6 +363,15 @@ impl ChainstateManager {
         unsafe { Chain::from_ptr(ptr) }
     }
 
+    pub fn best_entry(&self) -> Option<BlockTreeEntry<'_>> {
+        let ptr = unsafe { btck_chainstate_manager_get_best_entry(self.inner) };
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { BlockTreeEntry::from_ptr(ptr) })
+        }
+    }
+
     /// Get a block tree entry by its block hash.
     ///
     /// Looks up a block in the block tree using its hash. The block tree contains