feat(node): apply_block runs non-contextual consensus checks via verify_block_rules_borrowed

Op: extend

Author: metaphorics

crates/node/src/import.rs

@@ -49,7 +49,6 @@ pub fn import_block(state: &NodeState, block_bytes: &[u8]) -> Result<ImportOutco
 #[cfg(test)]
 mod tests {
     use super::*;
-    use bitcoin::TxMerkleNode;
     use bitcoin::consensus::Encodable as _;
     use tempfile::tempdir;
 
@@ -100,7 +99,9 @@ mod tests {
         let mut cursor = std::io::Cursor::new(genesis_bytes.as_slice());
         let mut follow_up = Block::consensus_decode(&mut cursor)?;
         follow_up.header.prev_blockhash = follow_up.block_hash();
-        follow_up.header.merkle_root = TxMerkleNode::from_byte_array([1_u8; 32]);
+        follow_up.header.merkle_root = follow_up
+            .compute_merkle_root()
+            .ok_or_else(|| anyhow::anyhow!("follow-up block should have merkle root"))?;
         follow_up.header.nonce = follow_up.header.nonce.wrapping_add(1);
 
         let mut follow_up_bytes = Vec::new();
@@ -123,6 +124,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn import_rejects_block_with_no_coinbase() -> Result<()> {
+        let genesis_bytes = hex_decode(REGTEST_GENESIS_HEX)?;
+        let mut cursor = std::io::Cursor::new(genesis_bytes.as_slice());
+        let mut block = Block::consensus_decode(&mut cursor)?;
+        block.txdata[0].input[0].previous_output = bitcoin::OutPoint {
+            txid: bitcoin::Txid::from_byte_array([1_u8; 32]),
+            vout: 0,
+        };
+        let merkle_root = block
+            .compute_merkle_root()
+            .ok_or_else(|| anyhow::anyhow!("mutated block should have merkle root"))?;
+        block.header.merkle_root = merkle_root;
+
+        let mut block_bytes = Vec::new();
+        block.consensus_encode(&mut block_bytes)?;
+
+        let dir = tempdir()?;
+        let mut config = crate::Config::default_for_network(crate::Network::Regtest);
+        config.data_dir = dir.path().join("node");
+        config.p2p_listen.clear();
+        let state = NodeState::open(config)?;
+
+        let Err(error) = import_block(&state, &block_bytes) else {
+            anyhow::bail!("block without coinbase should be rejected");
+        };
+
+        assert!(
+            error.chain().any(
+                |cause| cause.downcast_ref::<bitcoin_rs_consensus::ConsensusError>()
+                    == Some(&bitcoin_rs_consensus::ConsensusError::MissingCoinbase)
+            ),
+            "error chain should contain MissingCoinbase: {error:?}"
+        );
+        assert!(
+            state.chain_tip().load().is_none(),
+            "rejected block must not advance chain tip"
+        );
+        Ok(())
+    }
+
     fn hex_decode(hex: &str) -> Result<Vec<u8>> {
         let mut bytes = Vec::with_capacity(hex.len() / 2);
         let chars: Vec<char> = hex.chars().collect();

crates/node/src/state.rs

@@ -39,6 +39,9 @@ pub enum ApplyError {
     /// Height arithmetic overflowed `u32::MAX`.
     #[error("height overflow at tip {0}")]
     HeightOverflow(u32),
+    /// Consensus validation rejected the block.
+    #[error("consensus: {0}")]
+    Consensus(#[from] bitcoin_rs_consensus::ConsensusError),
     /// UTXO commit failed during block apply.
     #[error("utxo commit: {0}")]
     UtxoCommit(#[from] bitcoin_rs_utxo::UtxoError),
@@ -274,13 +277,13 @@ impl NodeState {
         crate::crash_recovery::write_meta(self, &meta)
     }
 
-    /// Synthetically applies `block` as the next tip without consensus validation.
+    /// Applies `block` as the next tip after non-contextual consensus checks.
     ///
     /// This is the v1 contract: the block hash is taken from the decoded
     /// header, the new height is `current_tip.height + 1` (or zero when no
     /// tip is published yet), chainwork is approximated by accumulating the
     /// block header's own work onto the prior tip's chainwork, and the block
-    /// is stored in `blocks` for RPC consumers. Real consensus validation,
+    /// is stored in `blocks` for RPC consumers. Contextual consensus checks,
     /// BIP30 / BIP34 / soft-fork checks, BIP9 deployment state, and reorg
     /// planning land in follow-up turns.
     ///
@@ -300,7 +303,7 @@ impl NodeState {
             bitcoin_rs_chain::node::ChainWork::from_be_bytes(block.header.work().to_be_bytes());
 
         let prior = self.chain_tip.load_full();
-        let (height, chainwork) = match prior {
+        let (height, chainwork) = match prior.as_deref() {
             Some(tip) => {
                 if tip.hash != prev_hash {
                     return Err(ApplyError::PrevHashMismatch {
@@ -317,6 +320,20 @@ impl NodeState {
             None => (0_u32, header_work),
         };
 
+        let prev_tip_state = match prior.as_deref() {
+            Some(tip) => bitcoin_rs_consensus::rust_path::TipState {
+                height: Some(tip.height),
+                block_hash: None,
+                median_time_past: 0,
+            },
+            None => bitcoin_rs_consensus::rust_path::TipState {
+                height: None,
+                block_hash: None,
+                median_time_past: 0,
+            },
+        };
+        bitcoin_rs_consensus::verify_block::verify_block_rules_borrowed(block, &prev_tip_state)?;
+
         let mut changes = BlockChanges::default();
         for tx in &block.txdata {
             let txid = tx.compute_txid();