fuzz: Add test for block and transaction accessors

Author: marcofleon

fuzz/Cargo.toml

@@ -41,3 +41,10 @@ path = "fuzz_targets/transaction_roundtrip.rs"
 test = false
 doc = false
 bench = false
+
+[[bin]]
+name = "kernel_primitives"
+path = "fuzz_targets/kernel_primitives.rs"
+test = false
+doc = false
+bench = false

fuzz/fuzz_targets/kernel_primitives.rs

@@ -0,0 +1,159 @@
+#![no_main]
+
+use arbitrary::Arbitrary;
+use libfuzzer_sys::fuzz_target;
+use bitcoinkernel::{
+    prelude::*,
+    Block, Transaction
+};
+
+#[derive(Debug, Arbitrary)]
+enum FuzzOperation {
+    ParseBlock {
+        data: Vec<u8>,
+    },
+    ParseTransaction {
+        data: Vec<u8>,
+    },
+    CompareBlockTxExtraction {
+        block_data: Vec<u8>,
+        tx_index: u16,
+    },
+}
+
+fuzz_target!(|op: FuzzOperation| {
+    match op {
+        FuzzOperation::ParseBlock { data } => {
+            let Ok(block) = Block::try_from(data.as_slice()) else {
+                return;
+            };
+
+            let tx_count = block.transaction_count();
+            assert_eq!(tx_count, block.transactions().count());
+
+            for (i, tx) in block.transactions().enumerate().take(1000) {
+                if let Ok(indexed_tx) = block.transaction(i) {
+                    assert_eq!(tx.txid(), indexed_tx.txid());
+                }
+
+                assert_eq!(tx.inputs().count(), tx.input_count());
+                assert_eq!(tx.outputs().count(), tx.output_count());
+
+                for (j, input) in tx.inputs().enumerate().take(10) {
+                    if let Ok(indexed_input) = tx.input(j) {
+                        let op1 = input.outpoint();
+                        let op2 = indexed_input.outpoint();
+                        assert_eq!(op1.txid(), op2.txid());
+                        assert_eq!(op1.index(), op2.index());
+                        assert_eq!(op1.is_null(), op2.is_null());
+                    }
+                }
+
+                for (j, output) in tx.outputs().enumerate().take(10) {
+                    if let Ok(indexed_output) = tx.output(j) {
+                        assert_eq!(output.value(), indexed_output.value());
+                        assert_eq!(
+                            output.script_pubkey().to_bytes(),
+                            indexed_output.script_pubkey().to_bytes()
+                        );
+                    }
+                }
+            }
+        }
+
+        FuzzOperation::ParseTransaction { data } => {
+            let Ok(tx) = Transaction::try_from(data.as_slice()) else {
+                return;
+            };
+
+            assert_eq!(tx.inputs().count(), tx.input_count());
+            assert_eq!(tx.outputs().count(), tx.output_count());
+
+            for (i, input) in tx.inputs().enumerate().take(10) {
+                if let Ok(indexed_input) = tx.input(i) {
+                    let op1 = input.outpoint();
+                    let op2 = indexed_input.outpoint();
+                    assert_eq!(op1.txid(), op2.txid());
+                    assert_eq!(op1.index(), op2.index());
+                }
+            }
+
+            for (i, output) in tx.outputs().enumerate().take(10) {
+                if let Ok(indexed_output) = tx.output(i) {
+                    assert_eq!(output.value(), indexed_output.value());
+                }
+            }
+        }
+
+        FuzzOperation::CompareBlockTxExtraction {
+            block_data,
+            tx_index,
+        } => {
+            let Ok(block) = Block::try_from(block_data.as_slice()) else {
+                return;
+            };
+
+            let Ok(tx_from_block) = block.transaction(tx_index as usize) else {
+                return;
+            };
+
+            let Ok(tx_bytes) = tx_from_block.consensus_encode() else {
+                return;
+            };
+
+            let Ok(standalone_tx) = Transaction::try_from(tx_bytes.as_slice()) else {
+                panic!(
+                    "Transaction at index {} is valid in block but failed to parse standalone (block has {} transactions)",
+                    tx_index,
+                    block.transaction_count()
+                );
+            };
+
+            assert_eq!(tx_from_block.txid(), standalone_tx.txid());
+            assert_eq!(tx_from_block.input_count(), standalone_tx.input_count());
+            assert_eq!(tx_from_block.output_count(), standalone_tx.output_count());
+
+            for (i, (orig_input, standalone_input)) in tx_from_block
+                .inputs()
+                .zip(standalone_tx.inputs())
+                .enumerate()
+                .take(10)
+            {
+                let op1 = orig_input.outpoint();
+                let op2 = standalone_input.outpoint();
+                assert_eq!(
+                    op1.txid(),
+                    op2.txid(),
+                    "Input {} outpoint txid mismatch",
+                    i
+                );
+                assert_eq!(
+                    op1.index(),
+                    op2.index(),
+                    "Input {} outpoint index mismatch",
+                    i
+                );
+            }
+
+            for (i, (orig_output, standalone_output)) in tx_from_block
+                .outputs()
+                .zip(standalone_tx.outputs())
+                .enumerate()
+                .take(10)
+            {
+                assert_eq!(
+                    orig_output.value(),
+                    standalone_output.value(),
+                    "Output {} value mismatch",
+                    i
+                );
+                assert_eq!(
+                    orig_output.script_pubkey().to_bytes(),
+                    standalone_output.script_pubkey().to_bytes(),
+                    "Output {} script mismatch",
+                    i
+                );
+            }
+        }
+    }
+});