fix(chain)!: In apply_changeset_to_checkpoint propagate the error from extend

Now that `extend` detects conflicts (via `push`) we need to handle
the error and propagate it up to `apply_update` in case `merge_chains`
fails.

Added `ApplyChangeSetError` struct internally but don't expose it.

Change `LocalChain::from_blocks` to propagate the error from
`CheckPoint::from_blocks`.

Author: ValuedMammal

crates/chain/src/local_chain.rs

@@ -11,11 +11,22 @@ pub use bdk_core::{CheckPoint, CheckPointIter};
 use bitcoin::block::Header;
 use bitcoin::BlockHash;
 
+/// Error for `apply_changeset_to_checkpoint`.
+#[derive(Debug)]
+struct ApplyChangeSetError<D> {
+    error: Option<CheckPoint<D>>,
+}
+
 /// Apply `changeset` to the checkpoint.
+///
+/// # Errors
+///
+/// - If constructing the new chain from the provided `changeset` fails, then a
+///   [`ApplyChangeSetError`] is returned.
 fn apply_changeset_to_checkpoint<D>(
     mut init_cp: CheckPoint<D>,
     changeset: &ChangeSet<D>,
-) -> Result<CheckPoint<D>, MissingGenesisError>
+) -> Result<CheckPoint<D>, ApplyChangeSetError<D>>
 where
     D: ToBlockHash + fmt::Debug + Copy,
 {
@@ -48,8 +59,11 @@ where
         let new_tip = match base {
             Some(base) => base
                 .extend(extension)
-                .expect("extension is strictly greater than base"),
-            None => LocalChain::from_blocks(extension)?.tip(),
+                .map_err(Option::Some)
+                .map_err(|error| ApplyChangeSetError { error })?,
+            None => LocalChain::from_blocks(extension)
+                .map_err(|error| ApplyChangeSetError { error })?
+                .tip(),
         };
         init_cp = new_tip;
     }
@@ -251,13 +265,16 @@ where
     ///
     /// The [`BTreeMap`] enforces the height order. However, the caller must ensure the blocks are
     /// all of the same chain.
-    pub fn from_blocks(blocks: BTreeMap<u32, D>) -> Result<Self, MissingGenesisError> {
+    ///
+    /// Returns `Err(None)` if `blocks` doesn't contain a value at height `0` a.k.a
+    /// "genesis" block.
+    pub fn from_blocks(blocks: BTreeMap<u32, D>) -> Result<Self, Option<CheckPoint<D>>> {
         if !blocks.contains_key(&0) {
-            return Err(MissingGenesisError);
+            return Err(None);
         }
 
         Ok(Self {
-            tip: CheckPoint::from_blocks(blocks).expect("blocks must be in order"),
+            tip: CheckPoint::from_blocks(blocks)?,
         })
     }
 
@@ -312,7 +329,8 @@ where
     /// Apply the given `changeset`.
     pub fn apply_changeset(&mut self, changeset: &ChangeSet<D>) -> Result<(), MissingGenesisError> {
         let old_tip = self.tip.clone();
-        let new_tip = apply_changeset_to_checkpoint(old_tip, changeset)?;
+        let new_tip =
+            apply_changeset_to_checkpoint(old_tip, changeset).map_err(|_| MissingGenesisError)?;
         self.tip = new_tip;
         debug_assert!(self._check_changeset_is_applied(changeset));
         Ok(())
@@ -702,9 +720,9 @@ where
         }
 
         // Apply changeset to tip.
-        let new_tip = apply_changeset_to_checkpoint(self.tip(), &changeset).map_err(|_| {
+        let new_tip = apply_changeset_to_checkpoint(self.tip(), &changeset).map_err(|e| {
             CannotConnectError {
-                try_include_height: 0,
+                try_include_height: e.error.as_ref().map_or(0, CheckPoint::height),
             }
         })?;