Replace map_err closures with ResultExt convenience methods (#606)

Add `map_err_display_alt`, `map_err_debug`, and `map_err_prefix` to `ResultExt`
trait, then replace all manual `.map_err(|e| Variant(e.to_string()))`
and similar patterns across the codebase with the appropriate method.

Author: praveenperera

rust/Cargo.lock

@@ -1,3 +1,4 @@
+use cove_util::ResultExt as _;
 use std::sync::{Arc, LazyLock, Mutex};
 
 use arc_swap::ArcSwapOption;
@@ -77,18 +78,15 @@ impl<S: CsppStore> Cspp<S> {
         let hex = hex::encode(master_key.as_bytes());
         let cryptor = Cryptor::new();
 
-        let encrypted =
-            cryptor.encrypt_to_string(&hex).map_err(|e| CsppError::Encrypt(e.to_string()))?;
+        let encrypted = cryptor.encrypt_to_string(&hex).map_err_str(CsppError::Encrypt)?;
 
         let encryption_key = cryptor.serialize_to_string();
 
         self.0
             .save(MASTER_KEY_ENCRYPTION_KEY_AND_NONCE.into(), encryption_key)
-            .map_err(|e| CsppError::Save(e.to_string()))?;
+            .map_err_str(CsppError::Save)?;
 
-        self.0
-            .save(MASTER_KEY_NAME.into(), encrypted)
-            .map_err(|e| CsppError::Save(e.to_string()))?;
+        self.0.save(MASTER_KEY_NAME.into(), encrypted).map_err_str(CsppError::Save)?;
 
         Ok(())
     }
@@ -103,15 +101,13 @@ impl<S: CsppStore> Cspp<S> {
             return Ok(None);
         };
 
-        let cryptor = Cryptor::try_from_string(&encryption_secret)
-            .map_err(|e| CsppError::Decrypt(e.to_string()))?;
+        let cryptor =
+            Cryptor::try_from_string(&encryption_secret).map_err_str(CsppError::Decrypt)?;
 
-        let hex = cryptor
-            .decrypt_from_string(&encrypted)
-            .map_err(|e| CsppError::Decrypt(e.to_string()))?;
+        let hex = cryptor.decrypt_from_string(&encrypted).map_err_str(CsppError::Decrypt)?;
 
         let bytes: [u8; 32] = hex::decode(hex)
-            .map_err(|e| CsppError::InvalidData(e.to_string()))?
+            .map_err_str(CsppError::InvalidData)?
             .try_into()
             .map_err(|_| CsppError::InvalidData("master key not 32 bytes".into()))?;
 

rust/crates/cove-cspp/src/cspp.rs

@@ -1,3 +1,4 @@
+use cove_util::ResultExt as _;
 use std::hash::Hash;
 use std::str::FromStr as _;
 use std::{hash::Hasher, sync::Arc};
@@ -147,7 +148,7 @@ impl Address {
         let script = output.script_pubkey.clone().into_boxed_script();
 
         let address = BdkAddress::from_script(&script, Params::from(network))
-            .map_err(|e| Error::ScriptError(e.to_string()))?;
+            .map_err_str(Error::ScriptError)?;
 
         Ok(Self::new(address))
     }

rust/crates/cove-types/src/address.rs

@@ -1,3 +1,4 @@
+use cove_util::ResultExt as _;
 use std::sync::Arc;
 
 use ahash::AHashMap as HashMap;
@@ -311,7 +312,7 @@ impl ConfirmDetails {
                 max_version: version,
             },
         )
-        .map_err(|e| ConfirmDetailsError::QrCodeCreation(e.to_string()))?;
+        .map_err_str(ConfirmDetailsError::QrCodeCreation)?;
 
         Ok(split.parts)
     }

rust/crates/cove-types/src/confirm.rs

@@ -1,5 +1,6 @@
 use bdk_wallet::psbt::PsbtUtils as _;
 use bitcoin::{Amount as BdkAmount, TxIn, TxOut};
+use cove_util::ResultExt as _;
 use derive_more::{AsRef, Deref, From, Into};
 use std::fmt::Debug;
 
@@ -48,7 +49,7 @@ impl Psbt {
     #[uniffi::constructor(name = "new")]
     #[allow(clippy::needless_pass_by_value)] // uniffi requires Vec by value
     pub fn try_new(data: Vec<u8>) -> Result<Self> {
-        let psbt = BdkPsbt::deserialize(&data).map_err(|e| PsbtError::Other(e.to_string()))?;
+        let psbt = BdkPsbt::deserialize(&data).map_err_str(PsbtError::Other)?;
         Ok(psbt.into())
     }
 

rust/crates/cove-types/src/psbt.rs

@@ -17,6 +17,7 @@ foundation-ur = { workspace = true }
 pubport = { workspace = true }
 hex = { workspace = true }
 tracing = { workspace = true }
+cove-util = { path = "../cove-util" }
 
 [dev-dependencies]
 serde_json = { workspace = true }

rust/crates/cove-ur/Cargo.toml

@@ -1,6 +1,7 @@
 //! crypto-coin-info: Cryptocurrency coin info
 //! BCR-2020-007: <https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-007-hdkey.md>
 
+use cove_util::ResultExt as _;
 use minicbor::{Decode, Encode};
 
 use crate::error::{Result, ToUrError, UrError};
@@ -31,7 +32,7 @@ impl CryptoCoinInfo {
     /// # Errors
     /// Returns error if CBOR encoding fails
     pub fn to_cbor(&self) -> Result<Vec<u8>> {
-        minicbor::to_vec(self).map_err(|e| UrError::CborEncodeError(e.to_string()))
+        minicbor::to_vec(self).map_err_str(UrError::CborEncodeError)
     }
 
     /// Decode from tagged CBOR

rust/crates/cove-ur/src/coin_info.rs

@@ -9,6 +9,7 @@
 //! 5. Derive macros cannot express this embedded CBOR pattern cleanly
 
 use bitcoin::bip32::{Xpriv, Xpub};
+use cove_util::ResultExt as _;
 use minicbor::{Decoder, Encoder, data::Tag};
 
 use crate::{
@@ -389,8 +390,8 @@ impl CryptoHdkey {
             return Err(UrError::MasterKeyNotAllowed);
         }
 
-        let public_key = PublicKey::from_slice(&self.key_data)
-            .map_err(|e| UrError::InvalidKeyData(e.to_string()))?;
+        let public_key =
+            PublicKey::from_slice(&self.key_data).map_err_str(UrError::InvalidKeyData)?;
 
         let chain_code = self
             .chain_code

rust/crates/cove-ur/src/crypto_hdkey.rs

@@ -7,6 +7,7 @@
 //! 3. Derive macros don't provide significant simplification for this structure
 
 use bitcoin::psbt::Psbt as BdkPsbt;
+use cove_util::ResultExt as _;
 use foundation_ur::{UR, bytewords};
 use minicbor::{Decoder, Encoder, data::Tag};
 
@@ -35,7 +36,7 @@ impl CryptoPsbt {
     /// Returns error if PSBT deserialization fails
     pub fn from_bytes(psbt_bytes: &[u8]) -> Result<Self> {
         let psbt = BdkPsbt::deserialize(psbt_bytes)
-            .map_err(|e| UrError::CborDecodeError(format!("Invalid PSBT: {e}")))?;
+            .map_err_prefix("Invalid PSBT", UrError::CborDecodeError)?;
         Ok(Self { psbt })
     }
 
@@ -63,10 +64,10 @@ impl CryptoPsbt {
         let mut encoder = Encoder::new(&mut buffer);
 
         // write tag 310
-        encoder.tag(Tag::new(CRYPTO_PSBT)).map_err(|e| UrError::CborEncodeError(e.to_string()))?;
+        encoder.tag(Tag::new(CRYPTO_PSBT)).map_err_str(UrError::CborEncodeError)?;
 
         // write PSBT as byte string
-        encoder.bytes(&psbt_bytes).map_err(|e| UrError::CborEncodeError(e.to_string()))?;
+        encoder.bytes(&psbt_bytes).map_err_str(UrError::CborEncodeError)?;
 
         Ok(buffer)
     }
@@ -95,7 +96,7 @@ impl CryptoPsbt {
 
         // deserialize PSBT
         let psbt = BdkPsbt::deserialize(&psbt_bytes)
-            .map_err(|e| UrError::CborDecodeError(format!("Invalid PSBT: {e}")))?;
+            .map_err_prefix("Invalid PSBT", UrError::CborDecodeError)?;
 
         Ok(Self { psbt })
     }
@@ -115,7 +116,7 @@ impl CryptoPsbt {
     /// # Errors
     /// Returns error if UR parsing or CBOR decoding fails
     pub fn from_ur_string(ur: &str) -> Result<Self> {
-        let ur = UR::parse(ur).map_err(|e| UrError::UrParseError(e.to_string()))?;
+        let ur = UR::parse(ur).map_err_str(UrError::UrParseError)?;
 
         // verify UR type
         if ur.as_type() != "crypto-psbt" {
@@ -130,7 +131,7 @@ impl CryptoPsbt {
             UR::SinglePart { message, .. } => {
                 // decode bytewords to bytes (UR uses minimal style)
                 bytewords::decode(message, bytewords::Style::Minimal)
-                    .map_err(|e| UrError::UrParseError(format!("Bytewords decode error: {e}")))?
+                    .map_err_prefix("Bytewords decode error", UrError::UrParseError)?
             }
             UR::SinglePartDeserialized { message, .. } => {
                 // already deserialized

rust/crates/cove-ur/src/crypto_psbt.rs

@@ -2,6 +2,7 @@
 //! BCR-2020-006: <https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-006-urtypes.md>
 
 use bip39::Mnemonic;
+use cove_util::ResultExt as _;
 use minicbor::{Decode, Encode};
 
 use crate::{
@@ -71,7 +72,7 @@ impl CryptoSeed {
     /// Returns error if entropy is invalid for BIP39
     pub fn to_mnemonic(&self) -> Result<Mnemonic> {
         Mnemonic::from_entropy(&self.payload)
-            .map_err(|e| UrError::InvalidField(format!("Invalid BIP39 entropy: {e}")))
+            .map_err_prefix("Invalid BIP39 entropy", UrError::InvalidField)
     }
 
     /// Encode as tagged CBOR
@@ -86,7 +87,7 @@ impl CryptoSeed {
             name: self.name.clone(),
             note: self.note.clone(),
         };
-        minicbor::to_vec(&cbor).map_err(|e| UrError::CborEncodeError(e.to_string()))
+        minicbor::to_vec(&cbor).map_err_str(UrError::CborEncodeError)
     }
 
     /// Decode from tagged CBOR