Add comprehensive tests for Coinbase type and block validation

Add thorough test coverage for the new Coinbase type and validation logic

Author: jrakibi

bitcoin/src/blockdata/block.rs

@@ -533,7 +533,10 @@ mod tests {
     use super::*;
     use crate::consensus::encode::{deserialize, serialize};
     use crate::pow::test_utils::{u128_to_work, u64_to_work};
+    use crate::script::ScriptBuf;
+    use crate::transaction::{OutPoint, Transaction, TxIn, TxOut, Txid};
     use crate::{block, CompactTarget, Network, TestnetVersion};
+    use crate::{Amount, Sequence, Witness};
 
     #[test]
     fn static_vector() {
@@ -781,6 +784,140 @@ mod tests {
         assert!(segwit_signal.is_signalling_soft_fork(1));
         assert!(!segwit_signal.is_signalling_soft_fork(2));
     }
+
+    #[test]
+    fn block_validation_no_transactions() {
+        let header = header();
+        let transactions = Vec::new(); // Empty transactions
+
+        let block = Block::new_unchecked(header, transactions);
+        match block.validate() {
+            Err(InvalidBlockError::NoTransactions) => (),
+            other => panic!("Expected NoTransactions error, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    fn block_validation_invalid_coinbase() {
+        let header = header();
+
+        // Create a non-coinbase transaction (has a real previous output, not all zeros)
+        let non_coinbase_tx = Transaction {
+            version: primitives::transaction::Version::TWO,
+            lock_time: crate::absolute::LockTime::ZERO,
+            input: vec![TxIn {
+                previous_output: OutPoint {
+                    txid: Txid::from_byte_array([1; 32]), // Not all zeros
+                    vout: 0,
+                },
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
+                witness: Witness::new(),
+            }],
+            output: vec![TxOut { value: Amount::ONE_BTC, script_pubkey: ScriptBuf::new() }],
+        };
+
+        let transactions = vec![non_coinbase_tx];
+        let block = Block::new_unchecked(header, transactions);
+
+        match block.validate() {
+            Err(InvalidBlockError::InvalidCoinbase) => (),
+            other => panic!("Expected InvalidCoinbase error, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    fn block_validation_success_with_coinbase() {
+        use crate::constants;
+
+        // Use the genesis block which has a valid coinbase
+        let genesis = constants::genesis_block(Network::Bitcoin);
+
+        let header = *genesis.header();
+        let transactions = genesis.transactions().to_vec();
+
+        let unchecked_block = Block::new_unchecked(header, transactions);
+        let validated_block = unchecked_block.validate();
+
+        assert!(validated_block.is_ok(), "Genesis block should validate successfully");
+    }
+
+    #[test]
+    fn checked_block_coinbase_method() {
+        use crate::constants;
+
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let coinbase = genesis.coinbase();
+
+        // Test that coinbase method returns the expected transaction
+        let expected_txid = genesis.transactions()[0].compute_txid();
+        assert_eq!(coinbase.compute_txid(), expected_txid);
+        assert_eq!(coinbase.wtxid(), Wtxid::COINBASE);
+
+        // Test that as_inner() returns the correct transaction
+        assert_eq!(coinbase.as_transaction(), &genesis.transactions()[0]);
+    }
+
+    #[test]
+    fn block_new_checked_validation() {
+        use crate::constants;
+
+        // Test successful validation with genesis block
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let header = *genesis.header();
+        let transactions = genesis.transactions().to_vec();
+
+        let checked_block = Block::new_checked(header, transactions.clone());
+        assert!(checked_block.is_ok(), "Genesis block should validate via new_checked");
+
+        // Test validation failure with empty transactions
+        let empty_result = Block::new_checked(header, Vec::new());
+        match empty_result {
+            Err(InvalidBlockError::NoTransactions) => (),
+            other => panic!("Expected NoTransactions error, got: {:?}", other),
+        }
+
+        // Test validation failure with invalid coinbase
+        let non_coinbase_tx = Transaction {
+            version: primitives::transaction::Version::TWO,
+            lock_time: crate::absolute::LockTime::ZERO,
+            input: vec![TxIn {
+                previous_output: OutPoint {
+                    txid: Txid::from_byte_array([1; 32]), // Not all zeros
+                    vout: 0,
+                },
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence::ENABLE_LOCKTIME_AND_RBF,
+                witness: Witness::new(),
+            }],
+            output: vec![TxOut { value: Amount::ONE_BTC, script_pubkey: ScriptBuf::new() }],
+        };
+
+        let invalid_coinbase_result = Block::new_checked(header, vec![non_coinbase_tx]);
+        match invalid_coinbase_result {
+            Err(InvalidBlockError::InvalidCoinbase) => (),
+            other => panic!("Expected InvalidCoinbase error, got: {:?}", other),
+        }
+    }
+
+    #[test]
+    fn coinbase_bip34_height_with_coinbase_type() {
+        // testnet block 100,000
+        const BLOCK_HEX: &str = "0200000035ab154183570282ce9afc0b494c9fc6a3cfea05aa8c1add2ecc56490000000038ba3d78e4500a5a7570dbe61960398add4410d278b21cd9708e6d9743f374d544fc055227f1001c29c1ea3b0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3703a08601000427f1001c046a510100522cfabe6d6d0000000000000000000068692066726f6d20706f6f6c7365727665726aac1eeeed88ffffffff0100f2052a010000001976a914912e2b234f941f30b18afbb4fa46171214bf66c888ac00000000";
+        let block: Block = deserialize(&hex!(BLOCK_HEX)).unwrap();
+        let block = block.assume_checked(None);
+
+        // Test that BIP34 height extraction works with the Coinbase type
+        assert_eq!(block.bip34_block_height(), Ok(100_000));
+
+        // Test that coinbase method returns a Coinbase type
+        let coinbase = block.coinbase();
+        assert!(coinbase.as_transaction().is_coinbase());
+
+        // Test that the coinbase transaction ID matches expected
+        let cb_txid = "d574f343976d8e70d91cb278d21044dd8a396019e6db70755a0a50e4783dba38";
+        assert_eq!(coinbase.compute_txid().to_string(), cb_txid);
+    }
 }
 
 #[cfg(bench)]

bitcoin/src/blockdata/transaction.rs

@@ -2127,6 +2127,25 @@ mod tests {
         let pretty_txid = "0x0000000000000000000000000000000000000000000000000000000000000000";
         assert_eq!(pretty_txid, format!("{:#}", &outpoint.txid));
     }
+
+    #[test]
+    fn coinbase_assume_methods() {
+        use crate::constants;
+        use crate::network::Network;
+
+        let genesis = constants::genesis_block(Network::Bitcoin);
+        let coinbase_tx = &genesis.transactions()[0];
+
+        // Test that we can create a Coinbase reference using assume_coinbase_ref
+        let coinbase_ref = Coinbase::assume_coinbase_ref(coinbase_tx);
+        assert_eq!(coinbase_ref.compute_txid(), coinbase_tx.compute_txid());
+        assert_eq!(coinbase_ref.wtxid(), Wtxid::COINBASE);
+
+        // Test that we can create a Coinbase using assume_coinbase
+        let coinbase_owned = Coinbase::assume_coinbase(coinbase_tx.clone());
+        assert_eq!(coinbase_owned.compute_txid(), coinbase_tx.compute_txid());
+        assert_eq!(coinbase_owned.wtxid(), Wtxid::COINBASE);
+    }
 }
 
 #[cfg(bench)]