Add block validation

Author: sedited

src/core/block.rs

@@ -8,8 +8,9 @@ use libbitcoinkernel_sys::{
     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_block_spent_outputs_create, 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_create, btck_coin_destroy,
     btck_coin_get_output, btck_coin_is_coinbase, btck_transaction_spent_outputs_copy,
     btck_transaction_spent_outputs_count, btck_transaction_spent_outputs_destroy,
     btck_transaction_spent_outputs_get_coin_at,
@@ -21,7 +22,7 @@ use crate::{
         c_helpers::present,
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
-    KernelError,
+    KernelError, TxOut,
 };
 
 use super::transaction::{TransactionRef, TxOutRef};
@@ -540,6 +541,36 @@ impl BlockSpentOutputs {
     pub fn as_ref(&self) -> BlockSpentOutputsRef<'_> {
         unsafe { BlockSpentOutputsRef::from_ptr(self.inner as *const _) }
     }
+
+    pub fn new(coins: &[Vec<Coin>]) -> Self {
+        struct CallbackContext<'a> {
+            coins: &'a [Vec<Coin>],
+        }
+
+        extern "C" fn coin_getter(
+            context: *mut c_void,
+            tx_index: usize,
+            coin_index: usize,
+        ) -> *const btck_Coin {
+            let ctx = unsafe { &*(context as *const CallbackContext) };
+            ctx.coins[tx_index][coin_index].as_ptr()
+        }
+
+        extern "C" fn count_getter(context: *mut c_void, tx_index: usize) -> usize {
+            let ctx = unsafe { &*(context as *const CallbackContext) };
+            ctx.coins[tx_index].len()
+        }
+
+        let context = CallbackContext { coins };
+        unsafe {
+            BlockSpentOutputs::from_ptr(btck_block_spent_outputs_create(
+                &context as *const CallbackContext as *mut c_void,
+                Some(coin_getter),
+                Some(count_getter),
+                coins.len(),
+            ))
+        }
+    }
 }
 
 impl FromMutPtr<btck_BlockSpentOutputs> for BlockSpentOutputs {
@@ -872,6 +903,10 @@ unsafe impl Send for Coin {}
 unsafe impl Sync for Coin {}
 
 impl Coin {
+    pub fn new(output: &TxOut) -> Coin {
+        unsafe { Coin::from_ptr(btck_coin_create(output.as_ptr(), 0, 0)) }
+    }
+
     pub fn as_ref(&self) -> CoinRef<'_> {
         unsafe { CoinRef::from_ptr(self.inner as *const _) }
     }

src/core/transaction.rs

@@ -6,10 +6,10 @@ use libbitcoinkernel_sys::{
     btck_transaction_count_outputs, btck_transaction_create, btck_transaction_destroy,
     btck_transaction_get_input_at, btck_transaction_get_output_at, btck_transaction_get_txid,
     btck_transaction_input_copy, btck_transaction_input_destroy,
-    btck_transaction_input_get_out_point, btck_transaction_out_point_copy,
-    btck_transaction_out_point_destroy, btck_transaction_out_point_get_index,
-    btck_transaction_out_point_get_txid, btck_transaction_output_copy,
-    btck_transaction_output_create, btck_transaction_output_destroy,
+    btck_transaction_input_get_out_point, btck_transaction_is_coinbase,
+    btck_transaction_out_point_copy, btck_transaction_out_point_destroy,
+    btck_transaction_out_point_get_index, btck_transaction_out_point_get_txid,
+    btck_transaction_output_copy, btck_transaction_output_create, btck_transaction_output_destroy,
     btck_transaction_output_get_amount, btck_transaction_output_get_script_pubkey,
     btck_transaction_to_bytes, btck_txid_copy, btck_txid_destroy, btck_txid_equals,
     btck_txid_to_bytes,
@@ -18,7 +18,7 @@ use libbitcoinkernel_sys::{
 use crate::{
     c_serialize,
     ffi::{
-        c_helpers::present,
+        c_helpers::{self, present},
         sealed::{AsPtr, FromMutPtr, FromPtr},
     },
     KernelError, ScriptPubkeyExt,
@@ -96,6 +96,10 @@ pub trait TransactionExt: AsPtr<btck_Transaction> {
     fn outputs(&self) -> TxOutIter<'_> {
         TxOutIter::new(unsafe { TransactionRef::from_ptr(self.as_ptr()) })
     }
+
+    fn is_coinbase(&self) -> bool {
+        unsafe { c_helpers::enabled(btck_transaction_is_coinbase(self.as_ptr())) }
+    }
 }
 
 /// A Bitcoin transaction.

src/state/chainstate.rs

@@ -39,6 +39,7 @@ use libbitcoinkernel_sys::{
     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_header,
+    btck_chainstate_manager_validate_block,
 };
 
 use crate::{
@@ -269,6 +270,23 @@ impl ChainstateManager {
         (c_helpers::success(accepted), state)
     }
 
+    pub fn validate_block(
+        &self,
+        block: &Block,
+        block_spent_outputs: &BlockSpentOutputs,
+    ) -> (bool, BlockValidationState) {
+        let state = BlockValidationState::new();
+        let accepted = unsafe {
+            btck_chainstate_manager_validate_block(
+                self.inner,
+                block.as_ptr(),
+                block_spent_outputs.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
@@ -277,6 +295,7 @@ impl ChainstateManager {
     ///
     /// # Errors
     /// Returns [`KernelError::Internal`] if initialization fails.
+
     pub fn import_blocks(&self) -> Result<(), KernelError> {
         let result = unsafe {
             btck_chainstate_manager_import_blocks(

tests/test.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod tests {
     use bitcoin::consensus::deserialize;
-    use bitcoinkernel::core::transaction::TxIn;
+    use bitcoinkernel::core::transaction::{TxIn, TxInExt, TxOutPointExt, TxOutPointRef};
     use bitcoinkernel::notifications::types::{BlockValidationStateExt, BlockValidationStateRef};
     use bitcoinkernel::{
         prelude::*, verify, Block, BlockHash, BlockSpentOutputs, BlockTreeEntry, ChainParams,
@@ -457,13 +457,74 @@ mod tests {
         let (context, data_dir) = testing_setup();
         let blocks_dir = data_dir.clone() + "/blocks";
         let block_data = read_block_data();
+        let blocks: Vec<Block> = block_data
+            .iter()
+            .map(|data| Block::new(data.as_slice()).unwrap())
+            .collect();
         let chainman = ChainstateManager::new(&context, &data_dir, &blocks_dir).unwrap();
 
-        for raw_block in block_data.iter() {
-            let block = Block::new(raw_block.as_slice()).unwrap();
+        for block in blocks.iter() {
+            let (accepted, state) = chainman.process_header(&block.header());
+            assert!(accepted);
+            assert_eq!(state.mode(), ValidationMode::Valid);
+        }
+    }
+
+    fn find_output<'a>(blocks: &'a [Block], outpoint: TxOutPointRef) -> Option<TxOut> {
+        for block in blocks.iter() {
+            for i in 0..block.transaction_count() {
+                let tx = block.transaction(i).unwrap();
+                if tx.txid() != outpoint.txid() {
+                    continue;
+                }
+                return tx
+                    .output(outpoint.index() as usize)
+                    .ok()
+                    .map(|out| out.to_owned());
+            }
+        }
+        None
+    }
+
+    #[test]
+    fn test_block_validation() {
+        let (context, data_dir) = testing_setup();
+        let blocks_dir = data_dir.clone() + "/blocks";
+        let block_data = read_block_data();
+        let blocks: Vec<Block> = block_data
+            .iter()
+            .map(|data| Block::new(data.as_slice()).unwrap())
+            .collect();
+        let chainman = ChainstateManager::new(&context, &data_dir, &blocks_dir).unwrap();
+
+        let mut block_spent_outputs: Vec<BlockSpentOutputs> = vec![];
+
+        for block in blocks.iter() {
+            let mut coins: Vec<Vec<Coin>> = vec![];
+            for i in 0..block.transaction_count() {
+                let tx = block.transaction(i).unwrap();
+                if tx.is_coinbase() {
+                    println!("tx is coinbase!");
+                    continue;
+                }
+                coins.push(Vec::new());
+                for j in 0..tx.input_count() {
+                    let output = find_output(&blocks, tx.input(j).unwrap().outpoint()).unwrap();
+                    println!("Accessing coins i {i}");
+                    coins[i - 1].push(Coin::new(&output));
+                }
+            }
+            block_spent_outputs.push(BlockSpentOutputs::new(&coins));
+        }
+
+        for (block, block_spent_outputs) in blocks.iter().zip(block_spent_outputs.iter()) {
             let (accepted, state) = chainman.process_header(&block.header());
             assert!(accepted);
             assert_eq!(state.mode(), ValidationMode::Valid);
+
+            let (result, state) = chainman.validate_block(block, &block_spent_outputs);
+            assert!(result);
+            assert_eq!(state.mode(), ValidationMode::Valid);
         }
     }