Merge #12: fix: no Debug on Display implementations

3c00f1a feat: add error messages for CreateWithPersistError Display implementation (Luis Schwab)
c799b52 fix: remove Debugs from CreateTxError (Luis Schwab)
1721b29 fix: no Debug on LoadError (Luis Schwab)
187a494 feat: implement Display for LoadMismatch (Luis Schwab)
0acd802 feat: implement Display for KeychainKind (Luis Schwab)

Pull request description:

  <!-- You can erase any parts of this template not applicable to your Pull Request. -->

  ### Description

  This PR removes the use of debugs on `Display` implemetations.

  ### Changelog notice
  - Implement Display for KeychainKind.
  - Implement Display for LoadMismatch.
  - Add error message for CreateWithPersistError.
  - The `CreateTxError::LockTime` arm had `requested` and `required` inverted, now fixed.
  - Remove debugs.

  ### Checklists

  #### All Submissions:

  * [X] I've signed all my commits
  * [X] I followed the [contribution guidelines](https://github.com/bitcoindevkit/bdk/blob/master/CONTRIBUTING.md)
  * [X] I ran `cargo fmt` and `cargo clippy` before committing

ACKs for top commit:
  notmandatory:
    utACK 3c00f1a

Tree-SHA512: a17984113e7ae4b49c5a5f5f711e80b8ffaf811b1d2f066e9b82cf454ae3ee33b67556bbf5bb61e082932f855ecace2d77d46ce514d457f5ad24a78fd9ae5aeb

Author: notmandatory

wallet/src/types.rs

@@ -12,6 +12,7 @@
 use alloc::boxed::Box;
 use chain::{ChainPosition, ConfirmationBlockTime};
 use core::convert::AsRef;
+use core::fmt;
 
 use bitcoin::transaction::{OutPoint, Sequence, TxOut};
 use bitcoin::{psbt, Weight};
@@ -37,6 +38,15 @@ impl KeychainKind {
     }
 }
 
+impl fmt::Display for KeychainKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            KeychainKind::External => write!(f, "External"),
+            KeychainKind::Internal => write!(f, "Internal"),
+        }
+    }
+}
+
 impl AsRef<[u8]> for KeychainKind {
     fn as_ref(&self) -> &[u8] {
         match self {

wallet/src/wallet/error.rs

@@ -112,7 +112,7 @@ impl fmt::Display for CreateTxError {
             Self::Descriptor(e) => e.fmt(f),
             Self::Policy(e) => e.fmt(f),
             CreateTxError::SpendingPolicyRequired(keychain_kind) => {
-                write!(f, "Spending policy required: {:?}", keychain_kind)
+                write!(f, "Spending policy required: {}", keychain_kind)
             }
             CreateTxError::Version0 => {
                 write!(f, "Invalid version `0`")
@@ -127,12 +127,12 @@ impl fmt::Display for CreateTxError {
                 requested,
                 required,
             } => {
-                write!(f, "TxBuilder requested timelock of `{:?}`, but at least `{:?}` is required to spend from this script", required, requested)
+                write!(f, "TxBuilder requested timelock of `{}`, but at least `{}` is required to spend from this script", requested, required)
             }
             CreateTxError::RbfSequenceCsv { sequence, csv } => {
                 write!(
                     f,
-                    "Cannot enable RBF with nSequence `{:?}` given a required OP_CSV of `{:?}`",
+                    "Cannot enable RBF with nSequence `{}` given a required OP_CSV of `{}`",
                     sequence, csv
                 )
             }

wallet/src/wallet/mod.rs

@@ -194,9 +194,9 @@ impl fmt::Display for LoadError {
             LoadError::MissingNetwork => write!(f, "loaded data is missing network type"),
             LoadError::MissingGenesis => write!(f, "loaded data is missing genesis hash"),
             LoadError::MissingDescriptor(k) => {
-                write!(f, "loaded data is missing descriptor for keychain {k:?}")
+                write!(f, "loaded data is missing descriptor for {k} keychain")
             }
-            LoadError::Mismatch(mismatch) => write!(f, "data mismatch: {mismatch:?}"),
+            LoadError::Mismatch(e) => write!(f, "{e}"),
         }
     }
 }
@@ -232,6 +232,44 @@ pub enum LoadMismatch {
     },
 }
 
+impl fmt::Display for LoadMismatch {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LoadMismatch::Network { loaded, expected } => {
+                write!(
+                    f,
+                    "Network mismatch: loaded {}, expected {}",
+                    loaded, expected
+                )
+            }
+            LoadMismatch::Genesis { loaded, expected } => {
+                write!(
+                    f,
+                    "Genesis hash mismatch: loaded {}, expected {}",
+                    loaded, expected
+                )
+            }
+            LoadMismatch::Descriptor {
+                keychain,
+                loaded,
+                expected,
+            } => {
+                write!(
+                    f,
+                    "Descriptor mismatch for {} keychain: loaded {}, expected {}",
+                    keychain,
+                    loaded
+                        .as_ref()
+                        .map_or("None".to_string(), |d| d.to_string()),
+                    expected
+                        .as_ref()
+                        .map_or("None".to_string(), |d| d.to_string())
+                )
+            }
+        }
+    }
+}
+
 impl From<LoadMismatch> for LoadError {
     fn from(mismatch: LoadMismatch) -> Self {
         Self::Mismatch(mismatch)

wallet/src/wallet/persisted.rs

@@ -6,10 +6,13 @@ use core::{
     pin::Pin,
 };
 
-use alloc::boxed::Box;
+use alloc::{boxed::Box, string::ToString};
 use chain::Merge;
 
-use crate::{descriptor::DescriptorError, ChangeSet, CreateParams, LoadParams, Wallet};
+use crate::{
+    descriptor::{calc_checksum, DescriptorError},
+    ChangeSet, CreateParams, LoadParams, Wallet,
+};
 
 /// Trait that persists [`PersistedWallet`].
 ///
@@ -361,16 +364,63 @@ pub enum CreateWithPersistError<E> {
 impl<E: fmt::Display> fmt::Display for CreateWithPersistError<E> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Persist(err) => fmt::Display::fmt(err, f),
-            Self::DataAlreadyExists(changeset) => write!(
-                f,
-                "Cannot create wallet in persister which already contains wallet data: {:?}",
-                changeset
-            ),
-            Self::Descriptor(err) => fmt::Display::fmt(&err, f),
+            Self::Persist(err) => write!(f, "{}", err),
+            Self::DataAlreadyExists(changeset) => {
+                write!(
+                    f,
+                    "Cannot create wallet in a persister which already contains data: "
+                )?;
+                changeset_info(f, changeset)
+            }
+            Self::Descriptor(err) => {
+                write!(f, "{err}")
+            }
         }
     }
 }
 
 #[cfg(feature = "std")]
 impl<E: fmt::Debug + fmt::Display> std::error::Error for CreateWithPersistError<E> {}
+
+/// Helper function to display basic information about a [`ChangeSet`].
+fn changeset_info(f: &mut fmt::Formatter<'_>, changeset: &ChangeSet) -> fmt::Result {
+    let network = changeset
+        .network
+        .as_ref()
+        .map_or("None".to_string(), |n| n.to_string());
+
+    let descriptor_checksum = changeset
+        .descriptor
+        .as_ref()
+        .and_then(|d| calc_checksum(&d.to_string()).ok())
+        .unwrap_or_else(|| "None".to_string());
+
+    let change_descriptor_checksum = changeset
+        .change_descriptor
+        .as_ref()
+        .and_then(|d| calc_checksum(&d.to_string()).ok())
+        .unwrap_or_else(|| "None".to_string());
+
+    let tx_count = changeset.tx_graph.txs.len();
+
+    let anchor_count = changeset.tx_graph.anchors.len();
+
+    let block_count = if let Some(&count) = changeset.local_chain.blocks.keys().last() {
+        count
+    } else {
+        0
+    };
+
+    writeln!(f, "  Network: {}", network)?;
+    writeln!(f, "  Descriptor Checksum: {}", descriptor_checksum)?;
+    writeln!(
+        f,
+        "  Change Descriptor Checksum: {}",
+        change_descriptor_checksum
+    )?;
+    writeln!(f, "  Transaction Count: {}", tx_count)?;
+    writeln!(f, "  Anchor Count: {}", anchor_count)?;
+    writeln!(f, "  Block Count: {}", block_count)?;
+
+    Ok(())
+}