migrating outgoing.rs to snafu error handling

src/error.rs

@@ -1,4 +1,5 @@
 use super::*;
+use bitcoin::address::Error as AddressError;
 
 #[derive(Debug, Snafu)]
 #[snafu(context(suffix(false)), visibility(pub(crate)))]
@@ -45,6 +46,39 @@ pub enum SnafuError {
   },
   #[snafu(display("Unrecognized representation `{}`", input))]
   UnrecognizedRepresentation { source: error::Error, input: String },
+  #[snafu(display("Unrecognized outgoing amount: `{}`", input))]
+  UnrecognizedAmount {
+    source: bitcoin::amount::ParseAmountError,
+    input: String,
+  },
+  #[snafu(display("Unrecognized outgoing rune: `{}`", input))]
+  UnrecognizedRune {
+    source: ordinals::spaced_rune::Error,
+    input: String,
+  },
+  #[snafu(display("Unrecognized outgoing sat: `{}`", input))]
+  UnrecognizedSat {
+    source: ordinals::sat::Error,
+    input: String,
+  },
+  #[snafu(display("Unrecognized outgoing sat point: `{}`", input))]
+  UnrecognizedSatPoint {
+    source: ordinals::sat_point::Error,
+    input: String,
+  },
+  #[snafu(display("Unrecognized outgoing inscription ID: `{}`", input))]
+  UnrecognizedInscriptionId {
+    source: inscriptions::inscription_id::ParseError,
+    input: String,
+  },
+  #[snafu(display("Unrecognized outgoing: `{}`", input))]
+  UnrecognizedOutgoing { input: String },
+  #[snafu(display("Failed to parse decimal: {}", source))]
+  DecimalParse { source: error::Error, input: String },
+  #[snafu(display("Invalid chain `{}`", chain))]
+  InvalidChain { chain: String },
+  #[snafu(display("Failed to convert script to address: {}", source))]
+  AddressConversion { source: AddressError },
   #[snafu(display("{err}"))]
   Anyhow { err: anyhow::Error },
   #[snafu(display("environment variable `{variable}` not valid unicode: `{}`", value.to_string_lossy()))]

src/outgoing.rs

@@ -22,9 +22,9 @@ impl Display for Outgoing {
 }
 
 impl FromStr for Outgoing {
-  type Err = Error;
+  type Err = SnafuError;
 
-  fn from_str(s: &str) -> Result<Self, Self::Err> {
+  fn from_str(input: &str) -> Result<Self, Self::Err> {
     lazy_static! {
       static ref AMOUNT: Regex = Regex::new(
         r"(?x)
@@ -63,22 +63,43 @@ impl FromStr for Outgoing {
       .unwrap();
     }
 
-    Ok(if re::SAT_NAME.is_match(s) {
-      Self::Sat(s.parse()?)
-    } else if re::SATPOINT.is_match(s) {
-      Self::SatPoint(s.parse()?)
-    } else if re::INSCRIPTION_ID.is_match(s) {
-      Self::InscriptionId(s.parse()?)
-    } else if AMOUNT.is_match(s) {
-      Self::Amount(s.parse()?)
-    } else if let Some(captures) = RUNE.captures(s) {
-      Self::Rune {
-        decimal: captures[1].parse()?,
-        rune: captures[2].parse()?,
-      }
+    if re::SAT_NAME.is_match(input) {
+      Ok(Outgoing::Sat(
+        input
+          .parse()
+          .snafu_context(error::UnrecognizedSat { input })?,
+      ))
+    } else if re::SATPOINT.is_match(input) {
+      Ok(Outgoing::SatPoint(
+        input
+          .parse()
+          .snafu_context(error::UnrecognizedSatPoint { input })?,
+      ))
+    } else if re::INSCRIPTION_ID.is_match(input) {
+      Ok(Outgoing::InscriptionId(
+        input
+          .parse()
+          .snafu_context(error::UnrecognizedInscriptionId { input })?,
+      ))
+    } else if AMOUNT.is_match(input) {
+      Ok(Outgoing::Amount(
+        input
+          .parse()
+          .snafu_context(error::UnrecognizedAmount { input })?,
+      ))
+    } else if let Some(captures) = RUNE.captures(input) {
+      let decimal = captures[1]
+        .parse::<Decimal>()
+        .snafu_context(error::DecimalParse { input })?;
+      let rune = captures[2]
+        .parse()
+        .snafu_context(error::RuneParse { input })?;
+      Ok(Self::Rune { decimal, rune })
     } else {
-      bail!("unrecognized outgoing: {s}");
-    })
+      Err(SnafuError::UnrecognizedOutgoing {
+        input: input.to_string(),
+      })
+    }
   }
 }