feat(chain,node): node_at_height_from + BIP68 time-based sequence-lock enforcement

Add BlockTree height backtracking for MTP lookup and enforce time-based BIP68 sequence locks using the prevout block's median time past.

Integration coverage for time-based BIP68 is intentionally out of scope because exercising it requires a CSV-active chain height with controlled timestamps.

Op: extend

Author: metaphorics

crates/chain/src/tree.rs

@@ -127,6 +127,37 @@ impl BlockTree {
         }
         locator
     }
+    /// Walks backward from `start_id` via parent pointers to the node at
+    /// `target_height`. Returns the `NodeId` at that height, or None if
+    /// `target_height > start_id.height` or the chain is broken.
+    #[must_use]
+    pub fn node_at_height_from(&self, start_id: NodeId, target_height: u32) -> Option<NodeId> {
+        let Ok(start_node) = self.node(start_id) else {
+            return None;
+        };
+        if target_height > start_node.height {
+            return None;
+        }
+        if target_height == start_node.height {
+            return Some(start_id);
+        }
+
+        let mut cursor = start_id;
+        loop {
+            let Ok(node) = self.node(cursor) else {
+                return None;
+            };
+            if node.height == target_height {
+                return Some(cursor);
+            }
+            if node.height < target_height {
+                return None;
+            }
+            let parent = node.parent?;
+            cursor = parent;
+        }
+    }
+
     /// Returns the median time of the most recent `window` blocks, inclusive
     /// of `start_id`, walking backward via parent pointers.
     ///
@@ -376,6 +407,44 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn node_at_height_from_walks_back_to_requested_height() -> Result<(), Box<dyn std::error::Error>>
+    {
+        let mut tree = BlockTree::new();
+        let mut prev_hash = BlockHash::all_zeros();
+        let mut genesis_id = None;
+        let mut tip_id = None;
+
+        for height in 0..5_u32 {
+            let header = BlockHeader {
+                version: Version::ONE,
+                prev_blockhash: prev_hash,
+                merkle_root: TxMerkleNode::all_zeros(),
+                time: 1_000_000 + height * 600,
+                bits: CompactTarget::from_consensus(0x207f_ffff),
+                nonce: height,
+            };
+            prev_hash = header.block_hash();
+            let node_id = tree.insert_header(header, NodeStatus::HeaderValid)?;
+            if height == 0 {
+                genesis_id = Some(node_id);
+            }
+            tip_id = Some(node_id);
+        }
+
+        let Some(genesis_id) = genesis_id else {
+            panic!("chain has 5 blocks should yield a genesis node");
+        };
+        let Some(tip_id) = tip_id else {
+            panic!("chain has 5 blocks should yield a tip");
+        };
+
+        assert_eq!(tree.node_at_height_from(tip_id, 0), Some(genesis_id));
+        assert_eq!(tree.node_at_height_from(tip_id, 4), Some(tip_id));
+        assert_eq!(tree.node_at_height_from(tip_id, 99), None);
+        Ok(())
+    }
+
     fn test_header(prev_blockhash: BlockHash, height: u32) -> BlockHeader {
         let mut merkle = [0_u8; 32];
         merkle[..4].copy_from_slice(&height.to_le_bytes());

crates/node/src/apply.rs

@@ -21,6 +21,7 @@ const COINBASE_MATURITY: u32 = 100;
 const BIP68_DISABLE_FLAG: u32 = 0x8000_0000;
 const BIP68_TYPE_FLAG: u32 = 0x0040_0000;
 const BIP68_MASK: u32 = 0x0000_ffff;
+const BIP68_TIME_GRANULARITY_SECONDS: u32 = 512;
 
 /// Owned shared handle set needed by `apply_block` to perform a block apply.
 pub struct ApplyHandles {
@@ -107,7 +108,7 @@ pub fn apply_block(
     verify_block_transactions(handles, block, height, prev_tip_state.median_time_past)?;
 
     check_coinbase_maturity(handles, block, height)?;
-    check_bip68_sequence_locks(handles, block, height)?;
+    check_bip68_sequence_locks(handles, block, height, prev_tip_state.median_time_past)?;
 
     let changes = build_utxo_changes(block, height)?;
     handles
@@ -235,6 +236,7 @@ fn check_bip68_sequence_locks(
     handles: &ApplyHandles,
     block: &bitcoin::Block,
     height: u32,
+    mtp: u32,
 ) -> core::result::Result<(), ApplyError> {
     use bitcoin::hashes::Hash as _;
 
@@ -256,10 +258,41 @@ fn check_bip68_sequence_locks(
             }
             let is_time_based = sequence & BIP68_TYPE_FLAG != 0;
             if is_time_based {
-                tracing::warn!(
-                    sequence = %format_args!("0x{sequence:08x}"),
-                    "BIP68 time-based sequence lock observed; enforcement deferred"
+                let relative_intervals = sequence & BIP68_MASK;
+                let prev_outpoint = OutPoint::new(
+                    bitcoin_rs_primitives::Hash256::from_le_bytes(
+                        tx_input.previous_output.txid.as_byte_array(),
+                    ),
+                    tx_input.previous_output.vout,
+                );
+                let Some(entry) = handles.utxo.get_entry(&prev_outpoint) else {
+                    continue;
+                };
+                let prevout_mtp = {
+                    let tree = handles.block_tree.read();
+                    let Some(chain_tip) = handles.chain_tip.load_full() else {
+                        continue;
+                    };
+                    let Some(prev_block_node) =
+                        tree.node_at_height_from(chain_tip.tip_id, entry.height)
+                    else {
+                        continue;
+                    };
+                    tree.median_time_past_at(prev_block_node, 11).unwrap_or(0)
+                };
+                let earliest_time = prevout_mtp.saturating_add(
+                    relative_intervals.saturating_mul(BIP68_TIME_GRANULARITY_SECONDS),
                 );
+                if mtp < earliest_time {
+                    return Err(ApplyError::Consensus(
+                        bitcoin_rs_consensus::ConsensusError::Bip {
+                            bip: "BIP68",
+                            reason: format!(
+                                "input sequence time-based lock unmet: prevout mtp {prevout_mtp} + {relative_intervals}*512s = {earliest_time} > current mtp {mtp}",
+                            ),
+                        },
+                    ));
+                }
                 continue;
             }