fix(core): fix CheckPoint::insert logic

Author: LagginTimes

crates/core/src/checkpoint.rs

@@ -2,6 +2,7 @@ use core::fmt;
 use core::ops::RangeBounds;
 
 use alloc::sync::Arc;
+use alloc::vec::Vec;
 use bitcoin::{block::Header, BlockHash};
 
 use crate::BlockId;
@@ -284,16 +285,21 @@ where
     /// all entries following it. If the existing checkpoint at height is a placeholder where
     /// `data: None` with the same hash, then the `data` is inserted to make a complete checkpoint.
     /// The returned chain will have a tip of the data passed in. If the data was already present
-    /// then this just returns `self`. This method does not create new placeholders.
+    /// then this just returns `self`.
+    ///
+    /// When inserting data with a `prev_blockhash` that conflicts with existing checkpoints,
+    /// those checkpoints will be displaced and replaced with placeholders. When inserting data
+    /// whose block hash conflicts with the `prev_blockhash` of higher checkpoints, those higher
+    /// checkpoints will be purged.
     ///
     /// # Panics
     ///
     /// This panics if called with a genesis block that differs from that of `self`.
     #[must_use]
     pub fn insert(self, height: u32, data: D) -> Self {
         let mut cp = self.clone();
-        let mut tail = vec![];
-        let base = loop {
+        let mut tail: Vec<(u32, D)> = vec![];
+        let mut base = loop {
             if cp.height() == height {
                 let same_hash = cp.hash() == data.to_blockhash();
                 if same_hash {
@@ -322,19 +328,88 @@ where
             cp = cp.prev().expect("will break before genesis block");
         };
 
-        base.extend(core::iter::once((height, data)).chain(tail.into_iter().rev()))
+        if let Some(prev_hash) = data.prev_blockhash() {
+            // Check if the new data's `prev_blockhash` conflicts with the checkpoint at height - 1.
+            if let Some(lower_cp) = base.get(height.saturating_sub(1)) {
+                // New data's `prev_blockhash` conflicts with existing checkpoint, so we displace
+                // the existing checkpoint and create a placeholder.
+                if lower_cp.hash() != prev_hash {
+                    // Find the base to link to at height - 2 or lower.
+                    let link_base = if height > 1 {
+                        base.floor_at(height - 2)
+                    } else {
+                        None
+                    };
+
+                    // Create a new placeholder at height - 1 with the required `prev_blockhash`.
+                    base = Self(Arc::new(CPInner {
+                        block_id: BlockId {
+                            height: height - 1,
+                            hash: prev_hash,
+                        },
+                        data: None,
+                        prev: link_base.map(|cb| cb.0).or_else(|| {
+                            // Keep any existing checkpoints below height - 2.
+                            if height > 1 {
+                                base.prev().map(|p| p.0)
+                            } else {
+                                None
+                            }
+                        }),
+                    }));
+                }
+            } else {
+                // No checkpoint at height - 1, but we may need to create a placeholder.
+                if height > 0 {
+                    base = Self(Arc::new(CPInner {
+                        block_id: BlockId {
+                            height: height - 1,
+                            hash: prev_hash,
+                        },
+                        data: None,
+                        prev: base.0.prev.clone(),
+                    }));
+                }
+            }
+        }
+
+        // Check for conflicts with higher checkpoints and purge if necessary.
+        let mut filtered_tail = Vec::new();
+        for (tail_height, tail_data) in tail.into_iter().rev() {
+            // Check if this tail entry's `prev_blockhash` conflicts with our new data's blockhash.
+            if let Some(tail_prev_hash) = tail_data.prev_blockhash() {
+                // Conflict detected, so purge this and all tail entries.
+                if tail_prev_hash != data.to_blockhash() {
+                    break;
+                }
+            }
+            filtered_tail.push((tail_height, tail_data));
+        }
+
+        base.extend(core::iter::once((height, data)).chain(filtered_tail))
             .expect("tail is in order")
     }
 
     /// Puts another checkpoint onto the linked list representing the blockchain.
     ///
     /// Returns an `Err(self)` if the block you are pushing on is not at a greater height that the
-    /// one you are pushing on to.
+    /// one you are pushing on to, or if the `prev_blockhash` conflicts with the current tip's hash
+    /// for contiguous heights.
     ///
     /// If `height` is non-contiguous and `data.prev_blockhash()` is available, a placeholder is
     /// created at height - 1.
     pub fn push(self, height: u32, data: D) -> Result<Self, Self> {
         if self.height() < height {
+            // For contiguous heights, validate prev_blockhash if available
+            if height == self.height() + 1 {
+                if let Some(prev_hash) = data.prev_blockhash() {
+                    if prev_hash != self.hash() {
+                        // Conflict: prev_blockhash doesn't match current tip's hash
+                        return Err(self);
+                    }
+                }
+            }
+
             let mut current_cp = self.0.clone();
 
             // If non-contiguous and `prev_blockhash` exists, insert a placeholder at height - 1.