Refactor: adapt to btckApi changes and implement rust idioms

Breaking changes:
- Replace BlockUndo with hierarchical
  BlockSpentOutputs/TransactionSpentOutputs/Coin design
- Remove get_ prefixes from all methods following rust naming
  conventions
- Introduce RefType<T, Owner> for zero-copy borrowing

Improvements:
- Add RefType wrapper for memory-safe borrowed references with
  compile-time lifetime guarantees
- Update internal bindings from kernel_ to btck_ prefixed C API
- Add input validation to verify function
- Add transaction and block iteration methods (output_count,
  transaction_count, etc.)
- Implement Clone traits using C copy functions
- Leverage C Library's smart ownershop tracking (m_owned flags) for safe
  borrowing
- Updated and improved documentation

Author: alexanderwiederin

examples/src/silentpaymentscanner.rs

@@ -162,21 +162,22 @@ fn scan_tx(receiver: &Receiver, secret_scan_key: &SecretKey, scan_tx_helper: Sca
 
 fn scan_txs(chainman: &ChainstateManager) {
     let (receiver, secret_scan_key) = parse_keys();
-    let mut block_index = chainman.get_block_index_tip();
+    let mut block_index = chainman.block_index_tip();
     loop {
         if block_index.height() <= 1 {
             break;
         }
-        let undo = chainman.read_undo_data(&block_index).unwrap();
+        let spent_outputs = chainman.read_spent_outputs(&block_index).unwrap();
         let raw_block: Vec<u8> = chainman.read_block_data(&block_index).unwrap().into();
         let block: bitcoin::Block = deserialize(&raw_block).unwrap();
         // Should be the same size minus the coinbase transaction
-        assert_eq!(block.txdata.len() - 1, undo.n_tx_undo);
+        assert_eq!(block.txdata.len() - 1, spent_outputs.count());
 
         for i in 0..(block.txdata.len() - 1) {
-            let transaction_undo_size: u64 = undo.get_transaction_undo_size(i.try_into().unwrap());
-            let transaction_input_size: u64 = block.txdata[i + 1].input.len().try_into().unwrap();
-            assert_eq!(transaction_input_size, transaction_undo_size);
+            let tx_spent_outputs = spent_outputs.transaction_spent_outputs(i).unwrap();
+            let coins_spent_count = tx_spent_outputs.count();
+            let transaction_input_size = block.txdata[i + 1].input.len();
+            assert_eq!(transaction_input_size, coins_spent_count);
             let mut scan_tx_helper = ScanTxHelper {
                 ins: vec![],
                 outs: block.txdata[i + 1]
@@ -186,21 +187,18 @@ fn scan_txs(chainman: &ChainstateManager) {
                     .collect(),
             };
             for j in 0..transaction_input_size {
+                let coin = tx_spent_outputs.coin(j).unwrap();
                 scan_tx_helper.ins.push(Input {
-                    prevout: undo
-                        .get_prevout_by_index(i as u64, j)
-                        .unwrap()
-                        .get_script_pubkey()
-                        .get(),
-                    script_sig: block.txdata[i + 1].input[j as usize].script_sig.to_bytes(),
-                    witness: block.txdata[i + 1].input[j as usize].witness.to_vec(),
+                    prevout: coin.output().unwrap().script_pubkey().to_bytes(),
+                    script_sig: block.txdata[i + 1].input[j].script_sig.to_bytes(),
+                    witness: block.txdata[i + 1].input[j].witness.to_vec(),
                     prevout_data: (
-                        block.txdata[i + 1].input[j as usize]
+                        block.txdata[i + 1].input[j]
                             .previous_output
                             .txid
                             .to_byte_array()
                             .to_vec(),
-                        block.txdata[i + 1].input[j as usize].previous_output.vout,
+                        block.txdata[i + 1].input[j].previous_output.vout,
                     ),
                 });
             }
@@ -229,7 +227,6 @@ fn main() {
     let blocks_dir = data_dir.clone() + "/blocks";
     let chainman = ChainstateManager::new(
         ChainstateManagerOptions::new(&context, &data_dir, &blocks_dir).unwrap(),
-        Arc::clone(&context),
     )
     .unwrap();
     chainman.import_blocks().unwrap();

fuzz/fuzz_targets/fuzz_target_chainman.rs

@@ -91,7 +91,7 @@ fuzz_target!(|data: ChainstateManagerInput| {
     .set_block_tree_db_in_memory(data.block_tree_db_in_memory)
     .set_chainstate_db_in_memory(data.chainstate_db_in_memory);
     chainman_opts.set_worker_threads(data.worker_threads);
-    let chainman = match ChainstateManager::new(chainman_opts, Arc::clone(&context)) {
+    let chainman = match ChainstateManager::new(chainman_opts) {
         Err(KernelError::Internal(_)) => {
             return;
         }

fuzz/fuzz_targets/fuzz_target_verify.rs

@@ -16,7 +16,7 @@ pub struct VerifyInput {
     pub script_pubkey: Vec<u8>,
     pub amount: Option<i64>,
     pub tx_to: Vec<u8>,
-    pub input_index: u32,
+    pub input_index: usize,
     pub flags: Option<u32>,
     pub spent_outputs: Vec<UtxoWrapper>,
 }